Hi Bill,

Let the receive function run unrestrained. It's the TX function that you want to run throttled.

Otherwise the TX is sending another TX packet and the poor RX hasn't processed the first packet - result is a hung system.

More fun to come program flow wise when you want 2 ways comms - sending back telemetry.....

I think we forget that even the standard 16 MHz Arduino is fast... really fast.

More stark when you talk it in terms of 16 Million cycles per second - with every tick of the clock, the CPU fetches and executes one instruction - still makes me smile - crazy technology.

Beam me up Scotty...

Regards
Jonathan _._

Hi Bill,

Good to see you are making progress - look forward to more updates.

I think we all tread the same path re our code development. I often spend many happy hours trying to find a set of code I wrote a while back - my filing system is quite logical but it still fails me frequently.

The software vs. hardware integrity is a challenge when developing a solution. Often we go looking for code issues when it's simply a poor connection. I have started to use "wire wrap" as a fast and pretty reliable way of connecting "stuff" - sure this will take some down memory lane.... The cost of genuine wire wrap tools will make your eyes water and your wallet feather light..

I will get back to posting about Arduino - been a very strange time for me... got less and greyer hair now having been playing with 1515 RGB Leds (1.5mm x 1.5mm SMT)

Regards
Jonathan _._

Bill,

Look forward to an update on your progress.

I have working scripts if you require, personally I don't like asking for help until I have reached the point of throwing the kit across the room or in the bin - I find being an Arduino Detective all part of the fun of getting something working, climbing inside the solution and logically reasoning what is wrong etc etc - I am sure you experience the same.

One thing you do need to be aware of is that you do not want to "send" every high frequency loop cycle - that simple fact could present itself as a non working solution as the external RFM69HCW does need some time (ms) to do it's stuff before being asked to do it again.

Much better to adopt - run my "send" function every X time period interval - suggest 200ms to start with

e.g.

long previousMillis = 0; // last time updated
long interval = 1000; // interval - our delay interval in milliseconds
void setup()
{
}
void loop()
{
unsigned long currentMillis = millis();
if(currentMillis - previousMillis > interval)
{
// time interval has been reach - run code here
previousMillis = currentMillis; // update the time we have run this event so we can compare with future time
}
}

Regards
Jonathan _._

Hi Tall Paul,

Current TX - 2.4GHz - probably surface to 50-75cms on a good day, with a following wind, winning lottery numbers etc.etc. 😊

Or 40 MHZ - 5-8 feet perhaps

Or UHF (459MHz) openLRS - maybe 100cm

Or 868MHz - no idea of depth.....

Best and most active place I know for Submarine help is

Facebook group - "Dive-in to Model Submarines"

Regards
Jonathan _._

Hi Bill,

Arduino RF data exchange - Test Script

Found this video from a while back so uploaded to YouTube.

Each line is a seperate data packet - this is throttled to 1 packet every 150ms

Jonathan _._

Testing RFM69HCW UHF Transceiver Arduino data exchange

▶️

Hi Bill,

You hit the nail on the head 100% re NRF24L01...

You will get quite a buzz when you see data appearing @ Arduino No.2 - still makes me smile.

I use extensively HOPERF RFM69HCW UHF 433MHz (424-510MHz configurable) devices - I have loads of them.

Not that you need it but the manufacturer handbook is 80 pages which hints at the product calibre.

They are brilliant little workhorses. They are quite sophisticated and I use them with the lowpowerlabs library.





It (radio/RF) is a great micro topic within the Arduino world.

Get ready to hit some brick walls:
> Like how do you receive a value greater than 255 - most devices send data as individual byte's and you may have to do some bitwise manipulation to add 2 bytes together at the reciever end

>Throttling the data exchange so it occurs for example 4 times a second and not continuously to allow other processes to exist harmoniously on your single core

etc etc.

Look forward to an update on your progress

Regards
Jonathan _._

https://cdn.sparkfun.com/datasheets/Wireless/General/RFM69HCW-V1.1.pdf

🔗

Hi Bill,

I spent a while on the various internet sites trying to unravel rules for use of SRD's in Ireland. They don't make finding the info easy! Seem to have been down many rabbit holes and not found an answer yet.

I will keep looking - perhaps you could use 2.4GHz using an NRF24L01

That said unless your "solution" is CE stamped (CEPT) then it will more than likely fall outside the strict letter of the law anyway.

Regards
Jonathan _._

Hi Bill,

See comments in other post re HC12 frequency change etc - My understanding 433MHz is not legal in UK for model control

From OFCOM site
458.500 - 459.500 MHz General model control (not airborne)

Many people doing Arduino and boat/sub projects

There is a forum dedicated to it with a few participants -

https://rcarduino.freeforums.net/

Regards
Jonathan _._

https://rcarduino.freeforums.net/

🔗

Hi Bill,

The HC12 can be used "barebones" for comms without any library - it simply acts like a wireless Serial Port.

Utilising the RadionHead library may give you some additional functionality. (Data Packets,CRC checks).

The HC12 can be "configured" using AT commands - you bring the "SET" pin low and then send your AT commands (change baud rate , radio channel (400Khz steps))

The failsafe needs to protect your project from data errors but most significantly from signal loss. If the motors are commanded to spin and you loose radio data link you have no way of stopping the motors (or steering) !! - forget what the specs say 1KM + the RF output/receiver capability for these devices is minimal and likely to drop out at some point.

I don't think the HC12 has an RSSI facility (signal strength) - many other RF devices do and it's a great thing to have...the software can monitor the "signal state". Indeed the remote transceiver can request an "ACK" from the shore based transceiver to see if it's still alive 😊

I have not used the HC12 but I have used many other Arduino comms devices with great success - BUT I have chosen not to use them to control the throttle or rudder on my models - I value them too much.......

Investigate using "constrain" for any "maps" or data values you use to command throttle,rudder - the map function is linear and does not trap rogue values passing through if you pass a rogue value in ( the fromLow & fromHigh parameters do not stop out of range values!!)

You will need to be mindful of the loop efficiency (latency)

And the last and most important point "Have fun with it" - hope my comments "add" to your journey - they at least might save a few more grey hairs 😊

Regards
Jonathan

What a great project...

Bill do think about a failsafe for your system - I have an "Arduinoer" friend that had "go fast stripes" added to the bottom of his lifeboat as it exited the pond and traversed across the tarmac (did some considerable damage)!!!

What frequency are you using - you should be able to set registers to crank it up to 459Mhz.

Doug 40-50 watts tuh! - ERP in the kW's thank you! 😊

Regards
Jonathan

Hi Martin,

Thank you for the question - I will make a post about data types, memory use, scope etc.

In answer to your question:

'int' - is a data type that allows you to store a whole number value from -32,768 to 32,767

e.g. int myAge=21; 😋

The const keyword prefix stands for constant (read only).

This means that the const variable can be used just as any other variable of its type, but its value cannot be changed

A good use of a constant would be: date of birth or Pi

const int dobYear = 1964;

'const' is used in the code example where we have defined a variable name referring to hardware pin(s). e.g.

const int ledPin = 13 ;

Clearly we do not want a coding error to change a hardware pin reference in normal use as this would lead to malfunctioning! So it's a belt and braces approach to eliminate this type of error ocurring, just a nice approach to adopt when declaring pin references. Should any part of the code attempt to modify the 'const' you will get a compile error.

Hope that helps
Jonathan

Here is the full code for a Bilge Water Alarm.

If you have followed this thread you should be able to follow what's going on - the video is using the same code as posted below.

Part of learning Arduino is uploading someone else's working code that you may not understand to your own Arduino board and then changing values etc and seeing what affect that has ....

Regards
Jonathan _._

+ + + + + + + + + + + + +

// Water Alarm 25/07/2020
// Use 2 wire probes located in the area that may contain water, place them a few cm's apart
// Connect one wire to a GND pin the other to Analog pin A0
// To make the sound we connect a small piezoelectric sounder to pin 6 and GND

int soundFreq = 700; // Sound frequency (in Hz)
int soundStep = 50; // Sound frequency increment - to make the alarm sound vary in pitch we will increment the tone frequency when it is triggered


const int ledPin = 13 ; // LED pin
const int soundPin = 6; // Ouput pin 6 connected to our piezoelectric sounder device
const int sensorPin = A0; // Simple piece of wire connected to pin A0 used as a probe located in area that may contain water

uint16_t sensorValue = 0; // variable to store the analog pin value when it is read using command analogRead(pin) - value will be in the range 0-1023

void setup() // Setup code - this runs once and sets up outpin etc.
{
pinMode(ledPin, OUTPUT) ; // define our ledPin as output
pinMode(soundPin, OUTPUT); // define our soundPin as output
pinMode(sensorPin, INPUT_PULLUP); // define our analog sensor pin as input - we are using pin A0
//digitalWrite(A0, INPUT_PULLUP); // Set the default state
}

void loop()
{
sensorValue = analogRead(sensorPin); // Read the analog value of A0 - will return a value between 0 and 1023
if (sensorValue > 1000) // test the analog sensor value now stored in variable "sensorValue" - if it's greater than 1000 then continue. If less than 1000 process the code defined by "else"
{
digitalWrite(ledPin, LOW);
noTone(soundPin);
delay(50);
}
else // if the sensoValue is less than 1000 then process the code below
{
digitalWrite(ledPin, HIGH); // Turn on the LED by setting the ledPin to High (5v)

// The code chunk below is used to make the frequency of the sound on the soundPin vary
// By increasing frequency to a preset value and then decreasing to a preset value - it then repeats each loop up & down in frequency to shape the alarm sound
tone(soundPin, soundFreq) ; // Set the soundPin to the value stored in soundFreq
soundFreq = soundFreq + soundStep; // increment the soundFreq by adding the value stored in the variable named soundStep - if soundStep = 50 the frequency will increase / if soundStep = - 50 the frequency will decrease
if (soundFreq == 1200) // test the soundFreq - if it's reached 1200 then
{
soundStep = -50; // change value of soundStep to - 50
}

if (soundFreq == 700) // test the soundFreq Value
{
soundStep = 50; // change value of soundStep to 50
}

delay(25); // pause 25ms
digitalWrite(ledPin, LOW); // turn the led pin off (0v) by setting the value to LOW
delay(25); pause 25ms
}
}


Below is the same code but without comments - might make easier reading as displayed on the forum.

int soundFreq = 700;
int soundStep = 50;

const int ledPin = 13 ;
const int soundPin = 6;
const int sensorPin = A0;

uint16_t sensorValue = 0;

void setup()
{
pinMode(ledPin, OUTPUT) ;
pinMode(soundPin, OUTPUT);
pinMode(sensorPin, INPUT_PULLUP);
//digitalWrite(A0, INPUT_PULLUP);
}

void loop()
{
sensorValue = analogRead(sensorPin);
if (sensorValue > 1000)
{
digitalWrite(ledPin, LOW);
noTone(soundPin);
delay(50);
}
else
{
digitalWrite(ledPin, HIGH);
tone(soundPin, soundFreq) ;
soundFreq = soundFreq + soundStep;
if (soundFreq == 1200)
{
soundStep = -50;
}

if (soundFreq == 700)
{
soundStep = 50;
}

delay(25);
digitalWrite(ledPin, LOW);
delay(25); pause 25ms
}
}

WaterAlarm

▶️

Apologies to those interested in this topic for the long gap between posts - life got in the way!

Summary of learning points so far:

> Arduino is open source – anybody can make the boards
> Arduino boards have inputs and outputs - analog (0-5v) and digital 0 or 5v
> We use the IDE to write our code and upload it via a USB cable to the Arduino board
> We need to tell the IDE which com “port” and type of Arduino board we are using
> Programs are also known as sketches
> Programs have 2 parts – SETUP runs once as the program starts and LOOP that runs continually
> DOCUMENT code as you create it using // This is a comment
> SAVE your code regularly using a new name each time, the name hints at what the program does – e.g. MyLedFlasher_001, MyLedFlasher_002, etc
> Syntax – a set of language rules you must comply with
>> Terminate lines with ;
>> Use upper and lower case appropriately where needed
>> Brackets always used in pairs – open and close
> We can send text from the Arduino to the IDE Serial Monitor popup window by using the command Serial.print()

Arduino has INPUTS and OUTPUTS

In this post we will use an input 'state' to send some text to the IDE Serial Monitor popup

The code below monitors the 'state' of one input pin (pin8) and depending on the 'state' of pin8 (HIGH or LOW) sends some text to the IDE Serial Monitor popup window.

To make pin 8 HIGH I connect a jumper cable between the Ardunio 5v pin and pin 8
To make pin 8 LOW I connect a jumper cable between the GND (ground or zero volt pin) and pin 8.

When using Arduino you will regularly come across the concept of pins (both INPUT and OUTPUT) being HIGH or LOW.

HIGH simply means that the pin is at 5 volts and LOW that the pin is at 0 volts (zero or GND (gound)) – NB Some Arduino’s are based around 3.3v logic not 5volt – I’ll cover this later

So:
HIGH = 5volts or logic value 1 (one)

and

LOW = 0 volts or logic value 0 (zero)

The HIGH or LOW are often referred to as “logic states”

To 'test' the logic state of the pin8 we will use the command digitalRead(8) – this will return one of two values – ‘1’ = the pin is high @ +5v or ‘0’ the pin is LOW @ 0v

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

We need a way to work with the result 1 (HIGH) or 0 (LOW) - the result of the digitalRead(8)

To do this we use the 'if' command.

The 'if' command checks for a condition (e.g. =1) and executes some code only if the condition is 'true'.

The code below will check if pin8 =1 and if true print text to the IDE Serial Monitor

void setup() // put your setup code here, to run once:
{
Serial.begin(9600); // start the serial communication
pinMode(8, INPUT); // set the pin 8 as INPUT
}

void loop() // put your main code here, to run repeatedly:
{
if (digitalRead(8)==1) // test if pin8 is HIGH (value of 1)
{
// if the above condition is 'true' send the text
// to the serial port which we can view in the IDE Serial Monitor

Serial.println("Digital pin 8 is HIGH");

}
}

A Youtube video link is attached that shows the output text in the IDE Serial monitor - it's not very exciting!

Well done if you have made it here !! we now have enough building blocks in place with some minor additions to do some more meaningful stuff....

Regards
Jonathan

Arduino Digital Read

▶️

SC,

What does the relay do in my ESC?

Regards
Jonathan

It's entirely possible that the antenna is a dipole.

If you look at the picture attached which is the anatomy of a "rubber duck" antenna you can see that the wire going into the bottom of the black plastic is coaxial (non radiating) and the 2 poles of the antenna are 180 degress apart from each other.

If you apply this concept to the FlySky antenna it is plausible (likely) that the thicker red part is the 2nd pole and the thin wire at the end the other pole

A scapel would confirm 😊

Regards

Jonathan

Hi Martin,

I have limited play time each week - I have recently been working with another model boater to create a two way serial data exchange module that turned out just fine but used up my play time so no tutorial publication here.

I find myself in a situation where every penny counts due to the pandemic - in my previous life I had a healthy monthy budget that I could spend on electronic gadgets without thinking twice... most of the examples I will publish are based around the Arduino Nano or esp32.

I will collate some of the suppliers I have used over the years and publish the list if that's ok with the forum owners(?)

Next installment to follow soon...

Regards
Jonathan

Well SeamanCook you have confused me!

I am really not sure what you mean by rivalry or what my post about Alan Bond's mixer & your ESC project has to do with Arduino in any way shape or form.

If there is any rivalry it's in your head not mine.

You raised a point about "a lot of hardware" I want to set the record straight - the image below if a fully functioning Bare Bones Arduino - as you will see not a lot of hardware hanging off the chip.

I wish you well with your ESC project

Jonathan

I may not have picked up on the fine detail of what you are working with/ trying to achieve so maybe this is a red herring - I may have misunderstood - I picked up that that yoo were scrapping the original "electrickery" and staring again...

Alan Bond is a well known modeller (Aircraft and Boats)

This is his website

http://www.forge-electronics.co.uk/index.php/boats

and the Rudder Mixer Mk2

http://www.forge-electronics.co.uk/index.php/boats/rudder-mi...

Regards
Jonathan

http://www.forge-electronics.co.uk/index.php/boats

🔗

http://www.forge-electronics.co.uk/index.php/boats/rudder-mixer

🔗

Looks a great project.

You say no commercial part will do this job - is the functionality not similar to Alan Bond's Rudder Mixer

https://www.technobotsonline.com/rudder-mixer-by-alan-bond.h...

Regards
Jonathan

https://www.technobotsonline.com/rudder-mixer-by-alan-bond.html

🔗

In case you missed it - the topic continues across in the "Build Blogs" section

https://model-boats.com/blogs/77106

And once you get there just click on the link "click to follow" to the right of the title if you are interested

Right now a quick look at a DGITAL SOUND DEVICE

Regards
Jonathan

https://model-boats.com/blogs/77106

🔗

Time for some carrots!!!

Putting in the time and energy to learn a new skill is hard work, until you reach the tipping point where things begin to fall into place it can all seem a bit confusing, boring and pointless.

Often initial motivation ebbs and the realisation of the new skill fades.

So time for something inspirational ....DIGITAL MULTI VOICE SOUND DEVICE

So these videos are of a guys amazing project which might re-ignite some motivation.

It's "Jedi" level so not for the next tutorial😉

There are many different sounds/ engine types that are available free and you can easily encode your own sound - yes it's in a truck but think how this concept could be transferred to a model boat - engine sound, horn, anchor, guns, sea gulls , general harbour noise ......

Total cost excluding small amplifier and speaker about £10

Oh and did I mention that this was Jedi level - it's a very complex project as published, hundreds and hundreds of lines of code and does some crazy amazing stuff - most not relevant to model boats - extract the good bits and we have a simple sound project which performs as well as some commercial boards costing 5 to 20 times the price....

However complex the code this is the single command that makes the noise

dacWrite(DAC1, Value);



Enjoy these videos - I hope you find them inspirational...

Jonathan

https://youtu.be/xKvJeDONK5M?t=28

https://youtu.be/qd8sOaW5Di4?t=29

https://youtu.be/kLBms7BGrdM?t=13

https://youtu.be/xKvJeDONK5M?t=28

🔗

https://youtu.be/qd8sOaW5Di4?t=29

🔗

https://youtu.be/kLBms7BGrdM?t=13

🔗

▶️

Hello Spock66 - thank you for your kind comments...

It looks like you have acheived some great projects with Arduino. I love the way that with any program there is more than one way to skin the cat - normally at least 3 ways to do the same thing.

The Morse programme is a great example - I have an alternative set of code which does the same thing but the approach is very different.

It was written by another radio amateur - Mark VandeWettering K6HX

The code can be accessed here - https://gist.github.com/dwhacks/9a73e444191ba1c08431

I have used his code to transmit live CW on 20 meters but don't remember getting any response👎

Regards
Jonathan

https://gist.github.com/dwhacks/9a73e444191ba1c08431

🔗

After this buidling block hopefully things will start to fall into place and become more interesting - hold the faith👍

The next building block we are going to cover is the IDE SERIAL MONITOR.

The SERIAL MONITOR allows us to “see” what is going “under the hood” of our program – it’s a bit like having a see-through oven door! to get used to how it works we will send a simple message from the Arduino to the IDE Serial Monitor on our desktop computer.

The SERIAL MONITOR is mainly used during program development & debugging to help identify what is going on inside our program LOOP as will be seen in the next tutorials..

Using the SERIAL MONITOR we can:

>>> Receive data from the Arduino serial port (serial = one character after the other)

>>> Send DATA to the Arduino serial port. (which I am not going to cover here)

The SERIAL MONITOR is accessed through the IDE command ribbon by selecting “TOOLS” and then “SERIAL MONITOR” - when selected a popup window opens on your computer which is the SERIAL MONITOR. (see pic 2)

To send serial data from the Arduino to the SERIAL MONITOR we have to:

In SETUP
Start the serial connection using the command Serial.begin(speed) where speed for serial communication is one of the following Supported baud rates are 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 31250, 38400, 57600, and 115200

In the program LOOP
We need to send data to the serial port - to do this we use this command

Serial.print(); an example might be Serial.print(“hello from your Arduino”);

Everything between the quote marks will be sent to the Arduino serial port and be received by the IDE SERIAL MONITOR via the USB cable and displayed in the desktop IDE popup window.

The serial monitor popup in image 3 is highlighted in yellow

The example program is detailed in image 1 and also below

void setup() // put your setup code here, to run once:
{
Serial.begin(9600); // start the serial connection at speed 9600 bits per second (baud rate)
}

void loop() // put your main code here, to run repeatedly:
{ // open bracket for the START of the main LOOP

// send the characters inside the quotes mark to the Arduino serial port

Serial.print("Hello from your Arduino ");

} // close bracket for the END of the main LOOP

and with all the // comments removed


void setup()
{
Serial.begin(9600);
}

void loop()
{
Serial.print("Hello from your Arduino ");
}



NOTES
# We need to make sure that the baud rate speed we set in the program SETUP – Serial.begin(9600); matches the SERIAL MONITOR baud rate – we can change the Serial Monitor baud rate by selecting a value from a drop down list just to the right at the bottom of the monitor popup window – if they don’t match you will either see lots of odd characters or nothing at all in your SERIAL MONITOR popup window

# A good speed to use to start with for the Serial Communication baud rate is 9600.

# The Arduino Uno and Nano only have one serial port. Other Arduino boards may have more serial ports and we would need to use a slightly different command as we would also refer to the serial port number e.g. SETUP serial3.begin(9600); and Serial3.print(“hello”);

Regards
Jonathan

Summary of learning points so far:

> Arduino is open source – anybody can make the boards
> Arduino boards have inputs and outputs - analog (0-5v) and digital 0 or 5v
> We use the IDE to write our code and upload it via a USB cable to the Arduino board
> We need to tell the IDE which com “port” and type of Arduino board we are using
> Programs are also known as sketches
> Programs have 2 parts – SETUP runs once as the program starts and LOOP that runs continually
> DOCUMENT code as you create it using // This is a comment
> SAVE your code regularly using a new name each time, the name hints at what the program does – e.g. MyLedFlasher_001, MyLedFlasher_002, etc
> Syntax – a set of language rules you must comply with
>> Terminate lines with ;
>> Use upper and lower case appropriately where needed
>> Brackets always used in pairs – open and close

Future topics we will cover:
+ Data types
+ Compiling code
+ Debugging code
+ Functions
+ Common programming structures/concepts e.g. "If this then do that"
+ Command sheets
+ Addin libraries
+ Interrupts
+ Serial monitor
+ Debouncing
+ i2c & SPI
+ PWM = pulse width modulation
+ Sensors
+ Arduino performance
+ How to power the Arduino
+ Quick glimpse at ATtiny, Teensy and esp32

And the command I hate the most “delay” - like driving a Ferrari with the hand brake on...

Regards
Jonathan

Hi Rick,

All Martin said and - Yes the Nano can be used - it's great for model boats as it has a small footprint. It is easy to connect more than one Nano together to form distributed processing if we need more input/output pins or more processing power.

Regards
Jonathan

HINTS AND TIPS

>>DOCUMENT your code as you go

We can add comments to our program code to help us understand what each line or section is doing. All text on the same line after a double forward slash is defined as a comment
e.g. // This is a comment

This has no effect on the program code or memory use when uploaded to the Arduino.

In a simple program this may seem unnecessary – it is however a good habit to adopt. When you open a program 6 months down the road you may find you look at the code you wrote and struggle to understand your long forgotten logic – it can be very annoying when you can’t understand your own code!

>>SAVE your program regularly with a different name

I use an approach where I give the program a name and suffix _xxx.

xxx is simply an incremental serial number “MyLedFlasher_001.ino”, “MyLedFlasher_002.ino” etc

Often my enthusiasm overruns and I change lots of lines of code all at the same time only to find the program does not do what I expected or results in an error. If you have overwritten your previous working copy with the same file name you will feel your blood pressure rising. When the going gets tough I rename after each and every change - trust me this approach pays dividends...

>>SYNTAX – what is it?

Definition = “the structure of statements in a computer language”

There are a set of rules (syntax) you need to comply with in order for the IDE to accept your program code as valid.

For example one syntax rule is most lines of code require the “line terminator character” – a semi colon to be added to each line of code to tell the IDE “end of line”.

If you make Syntax errors then the code will not upload(compile) to the Arduino board and you will be left with an orange error bar at the bottom of screen and some error text hinting at what might be wrong with your code.

Another example of a Syntax error is incorrect use of lower case or capital letters for program commands.

digitalWrite(LEDPin, HIGH); is valid syntax and works
digitalwrite(LEDPin, HIGH); is invalid syntax and does not work as the letter w is in lower case

Brackets are always used in pairs - open and close () or {} - it is easy when code gets more complex to omit a bracket

Get used to the orange error bar and syntax errors they happen all the time to all programmers – or at least it does for me.

You will get familiar with solving the errors over time – some can take a few minutes to work out what you have done wrong.

In the worst case it can be best to take a step backwards – open the previous saved working version, rename it so the working version is left untouched and then start again with your changes.

-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-

So that was some heavy stuff, on a lighter note looking forward to some of the upcoming projects I will touch on - very happy to add requests to this list

Bilge water alarm
Temperature Alarm
Dimming LED’s
Morse code & Aldis lamp signalling your own message
Simulating rotating emergency light
Moving a servo - this could be to let down a ramp or simulating gun turret movement
Slowing down servo movement
Running a servo movement sequence
Automatic ballast trim to correct/rebalance vessel leaning to one side or other
Active stabilisers
Reading the receiver channels
Engine sound device
Switching 16 circuits from just one transmitter stick
Holding a compass heading

Remember Rome was not built in a day - Be patient with yourself and enjoy this fascinating topic

Regards
Jonathan

If you have watched the “setting the scene” videos from Part 1 you should now be more familiar with some aspects of Arduino.

I am going to suggest that you don’t purchase any boards or accessories right now. Wait until we have covered a bit more of the topic – you will be able to judge then whether this is for you or not and therefore save wasting money.


In Summary:
> Arduino is open source and anybody can manufacture the boards – if not made by Arduino(Italy) then they should have a different name e.g. Seeeduino

> The boards have inputs and outputs (Analog 0-5v, Digital 0 or 5v)

> It is necessary to select the com (communication) "port" in the IDE that the Arduino board is connected to

> It is necessary to select which Arduino board type (Uno,Nano etc) you are using in the IDE

> Programs (also known as Sketches) are written in the free IDE computer software

> Programs are uploaded from the IDE to the Arduino board using a USB cable

The next video shows you how to write a very simple program to flash an LED - the full program code can be seen in the attached image


https://www.youtube.com/watch?v=d8_xXNcGYgo

Regards
Jonathan

https://www.youtube.com/watch?v=d8_xXNcGYgo

🔗

LESSON 1: Simple Introduction to the Arduino

▶️

If I learn to program an Arduino, how much will a typical installation cost? £15-£20

What is needed to get started? Arduino Uno or Nano board, USB cable, Computer, some jumper cables, a few LEDS, resistors

Are there several levels of equipment? Yes but Arduino Uno or Arduino Nano will suffice for a long time

Will the initial cost cover fault finding if I make a mistake? No - fault finding is down to you. There are support forums but the Official Arduino one is a scary place to hang out even for an experienced user! -

Is fault finding difficult? Yes & No - most of he time the IDE compiler will indicate what is wrong, most common fault is not terminating a line of code with a semi colon. After a while you get familiar with common issues and know what/where to look for error.

If I fail (again, I got nowhere with PICs), is there a second hand market for the bits? - Not really

Will my 16 channel controller become obsolete? No

I already have trouble knowing which button turns on which item....

If you are interested in learning more about Arduino then

Click on the link

https://model-boats.com/blogs/77106

🔗

PART ONE

Hello – it’s great to see that there are a bunch of you interested in Arduino and model boats

I love playing with Arduino, I learn something new almost every day and find it mentally stimulating and rewarding working through the “How can I do this” of an Arduino project.

It’s a big topic and comes with a set of it’s own jargon so it can be difficult to know where to start, how much is it going to cost, where can I purchase the boards etc. etc.

There are some fundamental building blocks that you need in place to be able to start your Arduino journey and it can be all to easy to give up on the subject when you hit a brick wall.

My approach will be blended learning – there are some fabulous free learning resources on the internet – these are top notch well thought out and well-presented short videos.

We all have different levels of understanding about Arduino – I will pitch the posts at those just starting their adventure – read on past if this is not you and and you come across familiar territory and maybe check back in when things get a bit more juicy.

A taster for some of the projects to come

A bilge water alarm - https://www.youtube.com/watch?v=HcpV0flL-zA

A Morse code/ Aldis flasher - https://www.youtube.com/watch?v=8_SiZkciRsA


No more waffle from me - lets scratch the surface of 2 of the building blocks – investing time watching these video a couple of times each will give you a good grounding in the subject.

Arduino Hardware overview and Arduino Integrated Development Environment – the free text editor like software where you create a program (from this point onwards referred to as the IDE)

The four videos below have some overlap but they give a great introduction - enjoy

https://youtu.be/nL34zDTPkcs

https://youtu.be/09zfRaLEasY

https://www.youtube.com/watch?v=fJWR7dBuc18

https://www.youtube.com/watch?v=CSx6k-zXlLE

This post is intended to set the scene and give you an overview of the subject

Please do post any questions / feedback

PART TWO will cover:
Writing your first program

Regards
Jonathan

https://www.youtube.com/watch?v=HcpV0flL-zA

🔗

https://www.youtube.com/watch?v=8_SiZkciRsA

🔗

https://youtu.be/nL34zDTPkcs

🔗

https://youtu.be/09zfRaLEasY

🔗

https://www.youtube.com/watch?v=fJWR7dBuc18

🔗

https://www.youtube.com/watch?v=CSx6k-zXlLE

🔗

▶️