Program Listings
Programming the Raspberry
Pi Pico/W in C
Second Edtion
We have decided not to make the programs available as a download because this is not the point of the book - the programs are not finished production code but something you should type in and study.
The best solution is to provide the source code of the programs in a form that can be copied and pasted into a NetBeans or VS Code project.
The only downside is that you have to create a project to paste the code into.
To do this follow the instructions in the book.
All of the programs below were copy and pasted from working programs in the IDE. They have been formatted using the built in formatter and hence are not identical in layout to the programs in the book. This is to make copy and pasting them easier. The programs in the book are formatted to be easy to read on the page.
If anything you consider important is missing or if you have any requests or comments contact:
This email address is being protected from spambots. You need JavaScript enabled to view it.
Page 27
#include "pico/stdlib.h"
int main() {
gpio_init(25);
gpio_set_dir(25, GPIO_OUT);
while (true) {
gpio_put(25, 1);
sleep_ms(500);
gpio_put(25, 0);
sleep_ms(500);
}
}
Page 28
cmake_minimum_required(VERSION 3.13)
include(pico_sdk_import.cmake)
project(blinky C CXX ASM)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
pico_sdk_init()
add_executable(blinky
blinky.c
)
target_link_libraries(blinky pico_stdlib)
pico_add_extra_outputs(blinky)
Page 29
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
int main() {
stdio_init_all();
cyw43_arch_init();
while (true) {
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
sleep_ms(500);
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
sleep_ms(500);
}
}
Page 30
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(blinky C CXX ASM)
pico_sdk_init()
add_executable(blinky
blinky.c
)
target_include_directories(blinky PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(blinky pico_cyw43_arch_none pico_stdlib)
pico_add_extra_outputs(blinky)
Page 36
{
"version": "0.2.0",
"configurations": [
{
"name": "Cortex Debug",
"cwd": "${workspaceRoot}",
"executable": "${command:cmake.launchTargetPath}",
"request": "launch",
"type": "cortex-debug",
"servertype": "openocd",
"gdbPath": "gdb-multiarch",
"device": "RP2040",
"configFiles": [
"interface/raspberrypi-swd.cfg",
"target/rp2040.cfg"
],
"svdFile":
"${env:PICO_SDK_PATH}/src/rp2040/hardware_regs/rp2040.svd",
"runToEntryPoint":"main",
// Give restart the same functionality as runToMain
"postRestartCommands": [
"break main",
"continue"
]
}
]
}
Page 40
{
"version": "0.2.0",
"configurations": [
{
"name": "Pico Debug",
"cwd": "${workspaceRoot}",
"executable": "${command:cmake.launchTargetPath}",
"request": "launch",
"type": "cortex-debug",
"servertype": "openocd",
"gdbPath": "arm-none-eabi-gdb",
"device": "RP2040",
"configFiles": [
"interface/picoprobe.cfg",
"target/rp2040.cfg"
],
"svdFile":"${env:PICO_SDK_PATH}/src/rp2040/
hardware_regs/rp2040.svd",
"runToEntryPoint":"main",
// Work around for stopping at main on restart
"postRestartCommands": [
"break main",
"continue"
]
}
]
}
Page 49
C File blinky2.c
#include "pico/stdlib.h"
int main()
{
gpio_init(22);
gpio_set_dir(22, true);
while (true)
{
gpio_put(22, 1);
sleep_ms(1000);
gpio_put(22, 0);
sleep_ms(1000);
}
}
CMAKE File
cmake_minimum_required(VERSION 3.13)
include(pico_sdk_import.cmake)
project(NewBlinky C CXX ASM)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
pico_sdk_init()
add_executable(blink
blinky2.c
)
target_link_libraries(blink pico_stdlib)
pico_add_extra_outputs(blink)
Page 56
#include "pico/stdlib.h"
int main()
{
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, true);
while (true)
{
gpio_put(22, 1);
gpio_put(22, 0);
}
}
Page 59
#include "pico/stdlib.h"
int main()
{
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, true);
while (true)
{
sleep_us(1);
gpio_put(22, 0);
sleep_us(1);
gpio_put(22, 1);
}
}
Page 60
#include "pico/stdlib.h"
int main()
{
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, true);
volatile int i;
int n = 1;
while (true)
{
for (i = 0; i < n; i++){};
gpio_put(22, 0);
for (i = 0; i < n; i++){};
gpio_put(22, 1);
}
}
Page 62
#include "pico/stdlib.h"
int main()
{
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, true);
gpio_set_function(21, GPIO_FUNC_SIO);
gpio_set_dir(21, true);
while (true)
{
gpio_put(22, 0);
gpio_put(21, 1);
gpio_put(22, 1);
gpio_put(21, 0);
}
}
Page 63
#include "pico/stdlib.h"
int main()
{
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, true);
gpio_set_function(21, GPIO_FUNC_SIO);
gpio_set_dir(21, true);
uint32_t mask = (1 << 22) | (1 << 21);
uint32_t value1 = 1 << 21;
uint32_t value2 = 1 << 22;
while (true)
{
gpio_put_masked(mask, value1);
gpio_put_masked(mask, value2);
}
}
Page 85
#include "pico/stdlib.h"
int main()
{
gpio_set_function(21, GPIO_FUNC_SIO);
gpio_set_dir(21, false);
gpio_pull_up(21);
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, true);
while (true)
{
if (gpio_get(21))
{
gpio_put(22, 0);
}
else
{
gpio_put(22, 1);
}
}
}
Page 86
#include "pico/stdlib.h"
int main()
{
gpio_set_function(21, GPIO_FUNC_SIO);
gpio_set_dir(21, false);
gpio_pull_down(21);
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, true);
gpio_put(22, 0);
while (true)
{
while (gpio_get(21) == 0)
{
};
while (gpio_get(21) == 1)
{
};
gpio_put(22, 1);
sleep_ms(1000);
gpio_put(22, 0);
}
}
Page 87
#include "pico/stdlib.h"
int main()
{
gpio_set_function(21, GPIO_FUNC_SIO);
gpio_set_dir(21, false);
gpio_pull_down(21);
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, true);
gpio_put(22, 0);
uint64_t t;
while (true)
{
while (gpio_get(21) == 0)
{
};
t = time_us_64();
sleep_ms(1);
while (gpio_get(21) == 1)
{
};
t = (uint64_t)(time_us_64() - t);
if (t < 2000 * 1000)
{
gpio_put(22, 1);
sleep_ms(1000);
gpio_put(22, 0);
}
else
{
for (int i = 0; i < 10; i++)
{
gpio_put(22, 1);
sleep_ms(100);
gpio_put(22, 0);
sleep_ms(100);
}
}
}
}
Page 89
#include <stdio.h>
#include "pico/stdlib.h"
int main()
{
stdio_init_all();
while (true) {
printf("Hello Serial World\n");
stdio_flush ();
sleep_ms(1000);
}
}
#include <stdio.h>
#include "pico/stdlib.h"
int main()
{
stdio_init_all();
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, false);
uint64_t t;
while (true)
{
while (gpio_get(22) == 1)
{
};
while (gpio_get(22) == 0)
{
};
t = time_us_64();
while (gpio_get(22) == 1)
{
};
t = (uint64_t)(time_us_64() - t);
printf("%llu\n", t);
sleep_ms(1000);
}
}
Page 92
#include <stdio.h>
#include "pico/stdlib.h"
int main()
{
stdio_init_all();
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, false);
uint64_t t;
int s = 0;
int i;
int count = 0;
while (true)
{
i = gpio_get(22);
t = time_us_64() + 100;
switch (s)
{
case 0: //button not pushed
if (i)
{
s = 1;
count++;
printf("Button Push %d \n\r", count);
}
break;
case 1: //Button pushed
if (!i)
{
s = 0;
}
break;
default:
s = 0;
}
sleep_until((absolute_time_t){t});
}
}
Page 94
#include <stdio.h>
#include "pico/stdlib.h"
int main()
{
stdio_init_all();
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, false);
uint64_t t;
uint64_t tpush, twait;
int s = 0, i;
int count = 0;
while (true)
{
i = gpio_get(22);
t = time_us_64();
switch (s)
{
case 0: //button not pushed
if (i)
{
s = 1;
tpush = t;
}
break;
case 1: //Button pushed
if (!i)
{
s = 0;
if ((t - tpush) > 2000000)
{
printf("Button held \n\r");
}
else
{
printf("Button pushed \n\r");
}
fflush(stdout);
}
break;
default:
s = 0;
}
sleep_until((absolute_time_t){t + 1000});
}
}
Page 96
#include <stdio.h>
#include "pico/stdlib.h"
int main()
{
stdio_init_all();
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, false);
gpio_set_function(21, GPIO_FUNC_SIO);
gpio_set_dir(21, true);
gpio_set_function(20, GPIO_FUNC_SIO);
gpio_set_dir(20, true);
gpio_set_function(19, GPIO_FUNC_SIO);
gpio_set_dir(19, true);
gpio_put(19, 1);
gpio_put(20, 0);
gpio_put(21, 0);
uint64_t t, tpush, twait;
int s = 0;
int buttonState = gpio_get(22);
int edge;
int buttonNow;
while (true)
{
t = time_us_64();
buttonNow = gpio_get(22);
edge = buttonState - buttonNow;
buttonState = buttonNow;
switch (s)
{
case 0:
if (edge == 1)
{
s = 1;
gpio_put(19, 0);
gpio_put(20, 1);
gpio_put(21, 0);
}
break;
case 1:
if (edge == 1)
{
s = 2;
gpio_put(19, 0);
gpio_put(20, 0);
gpio_put(21, 1);
}
break;
case 2:
if (edge == 1)
{
s = 0;
gpio_put(19, 1);
gpio_put(20, 0);
gpio_put(21, 0);
}
break;
default:
s = 0;
}
sleep_until((absolute_time_t){t + 1000});
}
}
Page 102
uint32_t gpio_get_events(uint gpio)
{
int32_t mask = 0xF << 4 * (gpio % 8);
return (iobank0_hw->intr[gpio / 8] & mask) >> 4 * (gpio % 8);
}
void gpio_clear_events(uint gpio, uint32_t events)
{
gpio_acknowledge_irq(gpio, events);
}
Page 103
#include <stdio.h>
#include "pico/stdlib.h"
int main()
{
stdio_init_all();
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, false);
gpio_pull_down(22);
printf("Press Button\n");
sleep_ms(20000);
if (gpio_get(22))
{
printf("Button Pressed\n");
}
else
{
printf("Button Not Pressed\n");
}
}
Page 103-104
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/structs/iobank0.h"
uint32_t gpio_get_events(uint gpio)
{
int32_t mask = 0xF << 4 * (gpio % 8);
return (iobank0_hw->intr[gpio / 8] & mask) >> 4 * (gpio % 8);
}
void gpio_clear_events(uint gpio, uint32_t events)
{
gpio_acknowledge_irq(gpio, events);
}
int main()
{
stdio_init_all();
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, false);
gpio_pull_down(22);
printf("Press Button\n");
gpio_clear_events(22, GPIO_IRQ_EDGE_RISE);
sleep_ms(20000);
int32_t event = gpio_get_events(22);
gpio_clear_events(22, GPIO_IRQ_EDGE_RISE);
if (event & GPIO_IRQ_EDGE_RISE)
{
printf("Button Pressed\n");
}
else
{
printf("Button Not Pressed\n");
}
}
Page 105
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/structs/iobank0.h"
uint32_t gpio_get_events(uint gpio)
{
int32_t mask = 0xF << 4 * (gpio % 8);
return (iobank0_hw->intr[gpio / 8] & mask) >> 4 * (gpio % 8);
}
void gpio_clear_events(uint gpio, uint32_t events)
{
gpio_acknowledge_irq(gpio, events);
}
int main()
{
uint64_t t;
stdio_init_all();
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, false);
gpio_pull_down(22);
while (true)
{
gpio_clear_events(22, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL);
while (!(gpio_get_events(22) & GPIO_IRQ_EDGE_RISE))
{
};
t = time_us_64();
gpio_clear_events(22, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL);
while (!(gpio_get_events(22) & GPIO_IRQ_EDGE_FALL))
{
};
t = (uint64_t)(time_us_64() - t);
printf("%llu\n", t);
sleep_ms(1000);
}
}
Page 107
#include <stdio.h>
#include "pico/stdlib.h"
static uint64_t t;
void MyIRQHandler(uint gpio, uint32_t events)
{
t = time_us_64() - t;
printf("GPIO %d %X %d \n", gpio, events, t);
}
int main()
{
stdio_init_all();
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, false);
gpio_pull_down(22);
gpio_set_irq_enabled_with_callback(22, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true, &MyIRQHandler);
while (1)
{
};
return 0;
}
Page 110
#include <stdio.h>
#include "pico/stdlib.h"
uint64_t t;
void MyIRQHandler(uint gpio, uint32_t events)
{
t = time_us_64() ;
printf("GPIO %d %X %d \n", gpio, events, t);
}
int main()
{
stdio_init_all();
gpio_set_function(22, GPIO_FUNC_SIO);
gpio_set_dir(22, false);
gpio_pull_down(22);
gpio_set_irq_enabled_with_callback(22, GPIO_IRQ_EDGE_RISE |
GPIO_IRQ_EDGE_FALL, true, &MyIRQHandler);
while (1)
{
printf("doing something\n\r");
};
return 0;
}
Page 124 complete program - remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan, uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
int main()
{
gpio_set_function(22, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(22);
uint chan = pwm_gpio_to_channel(22);
pwm_set_freq_duty(slice_num, chan, 50, 75);
pwm_set_enabled(slice_num, true);
return 0;
}
Page 125 complete program - remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num,uint chan,
uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16/16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num){
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
int main()
{
gpio_set_function(20, GPIO_FUNC_PWM);
gpio_set_function(21, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(20);
uint chan20 = pwm_gpio_to_channel(20);
uint chan21 = pwm_gpio_to_channel(21);
uint wrap = pwm_set_freq_duty(slice_num, chan20, 50, 75);
pwm_set_duty(slice_num, chan21, 25);
pwm_set_enabled(slice_num, true);
return 0;
}
Page 128 complete program - remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan,
uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
int main()
{
gpio_set_function(20, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(20);
uint chan20 = pwm_gpio_to_channel(20);
uint wrap = pwm_set_freq_duty(slice_num, chan20, 50, 50);
pwm_set_enabled(slice_num, true);
while (true)
{
pwm_set_duty(slice_num, chan20, 25);
pwm_set_duty(slice_num, chan20, 50);
}
return 0;
}
Page 129 complete program - remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan,
uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
int main()
{
gpio_set_function(20, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(20);
uint chan20 = pwm_gpio_to_channel(20);
uint wrap = pwm_set_freq_duty(slice_num, chan20, 50, 50);
pwm_set_enabled(slice_num, true);
while (true)
{
pwm_set_duty(slice_num, chan20, 25);
while (pwm_get_counter(slice_num))
{
};
pwm_set_duty(slice_num, chan20, 50);
while (pwm_get_counter(slice_num))
{
};
}
return 0;
}
Page 131 remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
#include "hardware/irq.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan, uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
uint slice_num;
uint chan20;
uint state = 0;
void MyIRQHandler()
{
pwm_clear_irq(slice_num);
if (state)
{
pwm_set_duty(slice_num, chan20, 25);
}
else
{
pwm_set_duty(slice_num, chan20, 50);
}
state = ~state;
}
int main()
{
gpio_set_function(20, GPIO_FUNC_PWM);
slice_num = pwm_gpio_to_slice_num(20);
chan20 = pwm_gpio_to_channel(20);
pwm_clear_irq(slice_num);
pwm_set_irq_enabled(slice_num, true);
irq_set_exclusive_handler(PWM_IRQ_WRAP, MyIRQHandler);
irq_set_enabled(PWM_IRQ_WRAP, true);
uint wrap = pwm_set_freq_duty(slice_num, chan20, 100000, 25);
pwm_set_enabled(slice_num, true);
while (true)
{
}
return 0;
}
Page 133 - 134 remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
#include "hardware/irq.h"
#include "math.h"
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
uint slice_num;
uint chan20;
uint state = 0;
uint8_t wave[256];
void MyIRQHandler()
{
pwm_clear_irq(slice_num);
pwm_set_duty(slice_num, chan20, wave[state]);
state = (state + 1) % 256;
}
int main()
{
for (int i = 0; i < 256; i++)
{
wave[i] = (uint8_t)((128.0 + sinf((float)i * 2.0 * 3.14159 / 256.0) * 128.0) * 100.0 / 256.0);
}
gpio_set_function(22, GPIO_FUNC_PWM);
slice_num = pwm_gpio_to_slice_num(22);
uint chan22 = pwm_gpio_to_channel(22);
pwm_clear_irq(slice_num);
pwm_set_irq_enabled(slice_num, true);
irq_set_exclusive_handler(PWM_IRQ_WRAP, MyIRQHandler);
irq_set_enabled(PWM_IRQ_WRAP, true);
pwm_set_clkdiv_int_frac(slice_num, 1, 0);
pwm_set_wrap(slice_num, 255);
pwm_set_enabled(slice_num, true);
while (true)
{
}
return 0;
}
Page 135 complte program remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan, uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
int main()
{
gpio_set_function(22, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(22);
uint chan22 = pwm_gpio_to_channel(22);
pwm_set_freq_duty(slice_num, chan22, 281, 50);
pwm_set_enabled(slice_num, true);
}
Page 136 complete program remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan, uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
int main()
{
gpio_set_function(25, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(25);
uint chan = pwm_gpio_to_channel(25);
pwm_set_freq_duty(slice_num, chan, 2000, 0);
pwm_set_enabled(slice_num, true);
while (true)
{
for (int d = 0; d <= 100; d++)
{
pwm_set_duty(slice_num, chan, d);
sleep_ms(50);
}
}
}
Page 138 complete program remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan, uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
int main()
{
gpio_set_function(25, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(25);
uint chan = pwm_gpio_to_channel(25);
pwm_set_freq_duty(slice_num, chan, 2000, 0);
pwm_set_enabled(slice_num, true);
int d = 0;
while (true)
{
for (int b = 0; b <= 100; b++)
{
d = (b * b * b) / 10000;
pwm_set_duty(slice_num, chan, d);
sleep_ms(50);
}
}
}
Page 140 remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
int main()
{
gpio_set_function(20, GPIO_FUNC_PWM);
gpio_set_function(21, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(20);
uint chanA = pwm_gpio_to_channel(20);
uint chanB = pwm_gpio_to_channel(21);
pwm_set_clkdiv_int_frac(slice_num, 2, 0);
pwm_set_wrap(slice_num, 127);
pwm_set_chan_level(slice_num, chanA, 63);
pwm_set_clkdiv_mode(slice_num, PWM_DIV_B_RISING);
pwm_set_enabled(slice_num, true);
}
Page 142 remember to add hardware_pwm to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/pwm.h"
int main()
{
stdio_init_all();
gpio_set_function(20, GPIO_FUNC_PWM);
gpio_set_function(21, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(20);
uint chanA = pwm_gpio_to_channel(20);
uint chanB = pwm_gpio_to_channel(21);
pwm_set_clkdiv_int_frac(slice_num, 20, 0);
int maxcount = 125000000 * 10 / 20 / 1000;
pwm_set_wrap(slice_num, 65535);
pwm_set_chan_level(slice_num, chanA, 100);
pwm_set_clkdiv_mode(slice_num, PWM_DIV_B_HIGH);
while (true)
{
pwm_set_enabled(slice_num, true);
sleep_ms(10);
pwm_set_enabled(slice_num, false);
uint16_t count = pwm_get_counter(slice_num);
pwm_set_counter(slice_num, 0);
printf("count= %u duty cycle=%d %%\n",
count, (int)count * 100 / maxcount);
sleep_ms(1000);
}
}
Page 150,152,152 remember to add hardware_pwm to the CMakeLists.txt file
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan, uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
typedef struct
{
uint gpio;
uint slice;
uint chan;
uint speed;
uint freq;
uint resolution;
bool on;
} Motor;
void motorInit(Motor *m, uint gpio, uint freq)
{
gpio_set_function(gpio, GPIO_FUNC_PWM);
m->gpio = gpio;
m->slice = pwm_gpio_to_slice_num(gpio);
m->chan = pwm_gpio_to_channel(gpio);
m->freq = freq;
m->speed = 0;
m->resolution = pwm_set_freq_duty(m->slice, m->chan, m->freq, m->speed);
m->on = false;
}
void motorspeed(Motor *m, int s)
{
pwm_set_duty(m->slice, m->chan, s);
m->speed = s;
}
void motorOn(Motor *m)
{
pwm_set_enabled(m->slice, true);
m->on = true;
}
void motorOff(Motor *m)
{
pwm_set_enabled(m->slice, false);
m->on = false;
}
int main()
{
Motor mot1;
motorInit(&mot1, 21, 2000);
motorspeed(&mot1, 50);
motorOn(&mot1);
return 0;
}
Page 156 remember to add hardware_pwm to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan, uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
typedef struct
{
uint gpioForward;
uint gpioBackward;
uint slice;
uint Fchan;
uint Bchan;
bool forward;
uint speed;
uint freq;
uint resolution;
bool on;
} BiMotor;
void BiMotorInit(BiMotor *m, uint gpioForward, uint gpioBackward, uint freq)
{
gpio_set_function(gpioForward, GPIO_FUNC_PWM);
m->gpioForward = gpioForward;
m->slice = pwm_gpio_to_slice_num(gpioForward);
m->Fchan = pwm_gpio_to_channel(gpioForward);
gpio_set_function(gpioBackward, GPIO_FUNC_PWM);
m->gpioBackward = gpioBackward;
m->Bchan = pwm_gpio_to_channel(gpioBackward);
m->freq = freq;
m->speed = 0;
m->forward = true;
m->resolution = pwm_set_freq_duty(m->slice, m->Fchan, m->freq, 0);
pwm_set_duty(m->slice, m->Bchan, 0);
m->on = false;
}
void BiMotorspeed(BiMotor *m, int s, bool forward)
{
if (forward)
{
pwm_set_duty(m->slice, m->Bchan, 0);
pwm_set_duty(m->slice, m->Fchan, s);
m->forward = true;
}
else
{
pwm_set_duty(m->slice, m->Fchan, 0);
pwm_set_duty(m->slice, m->Bchan, s);
m->forward = true;
}
m->speed = s;
}
void BiMotorOn(BiMotor *m)
{
pwm_set_enabled(m->slice, true);
m->on = true;
}
void BiMotorOff(BiMotor *m)
{
pwm_set_enabled(m->slice, false);
m->on = false;
}
int main()
{
BiMotor mot1;
BiMotorInit(&mot1, 20, 21, 2000);
BiMotorOn(&mot1);
while (true)
{
BiMotorspeed(&mot1, 50, true);
sleep_ms(2000);
BiMotorspeed(&mot1, 25, false);
sleep_ms(2000);
}
return 0;
}
Page 162, 163, 164 remember to add hardware_pwm to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/pwm.h"
uint32_t pwm_set_freq_duty(uint slice_num, uint chan, uint32_t f, int d)
{
uint32_t clock = 125000000;
uint32_t divider16 = clock / f / 4096 + (clock % (f * 4096) != 0);
if (divider16 / 16 == 0)
divider16 = 16;
uint32_t wrap = clock * 16 / divider16 / f - 1;
pwm_set_clkdiv_int_frac(slice_num, divider16 / 16, divider16 & 0xF);
pwm_set_wrap(slice_num, wrap);
pwm_set_chan_level(slice_num, chan, wrap * d / 100);
return wrap;
}
uint32_t pwm_get_wrap(uint slice_num)
{
valid_params_if(PWM, slice_num >= 0 && slice_num < NUM_PWM_SLICES);
return pwm_hw->slice[slice_num].top;
}
void pwm_set_duty(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 100);
}
void pwm_set_dutyH(uint slice_num, uint chan, int d)
{
pwm_set_chan_level(slice_num, chan, pwm_get_wrap(slice_num) * d / 10000);
}
typedef struct
{
uint gpio;
uint slice;
uint chan;
uint speed;
uint resolution;
bool on;
bool invert;
} Servo;
void ServoInit(Servo *s, uint gpio, bool invert)
{
gpio_set_function(gpio, GPIO_FUNC_PWM);
s->gpio = gpio;
s->slice = pwm_gpio_to_slice_num(gpio);
s->chan = pwm_gpio_to_channel(gpio);
pwm_set_enabled(s->slice, false);
s->on = false;
s->speed = 0;
s->resolution = pwm_set_freq_duty(s->slice, s->chan, 50, 0);
pwm_set_dutyH(s->slice, s->chan, 250);
if (s->chan)
{
pwm_set_output_polarity(s->slice, false, invert);
}
else
{
pwm_set_output_polarity(s->slice, invert, false);
}
s->invert = invert;
}
void ServoOn(Servo *s)
{
pwm_set_enabled(s->slice, true);
s->on = true;
}
void ServoOff(Servo *s)
{
pwm_set_enabled(s->slice, false);
s->on = false;
}
void ServoPosition(Servo *s, uint p)
{
pwm_set_dutyH(s->slice, s->chan, p * 10 + 250);
}
int main()
{
Servo s1;
ServoInit(&s1, 20, false);
ServoOn(&s1);
while (true)
{
ServoPosition(&s1, 0);
sleep_ms(500);
ServoPosition(&s1, 100);
sleep_ms(500);
}
return 0;
}
Page 173,174 remember to add hardware_pwm to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
typedef struct
{
uint gpio;
uint speed;
bool forward;
uint32_t gpiomask;
uint phase;
} StepperBi;
uint32_t stepTable[8] = (uint32_t[8]){0x8, 0xC, 0x4, 0x6, 0x2, 0x3, 0x1, 0x9};
/*
{1, 0, 0, 0},
{1, 1, 0, 0},
{0, 1, 0, 0},
{0, 1, 1, 0},
{0, 0, 1, 0},
{0, 0, 1, 1},
{0, 0, 0, 1},
{1, 0, 0, 1}
*/
void StepperBiInit(StepperBi *s, uint gpio)
{
s->gpio = gpio;
for (int i = 0; i < 4; i++)
{
gpio_set_function((s->gpio) + i, GPIO_FUNC_SIO);
gpio_set_dir((s->gpio) + i, true);
}
s->gpiomask = 0x0F << gpio;
volatile uint32_t mask = stepTable[0] << gpio;
gpio_put_masked(s->gpiomask, mask);
s->phase = 0;
s->speed = 0;
s->forward = true;
}
void setPhase(StepperBi *s, uint p)
{
uint32_t mask = stepTable[p] << (s->gpio);
gpio_put_masked(s->gpiomask, mask);
}
void stepForward(StepperBi *s)
{
s->phase = (s->phase + 1) % 8;
setPhase(s, s->phase);
}
void stepReverse(StepperBi *s)
{
s->phase = (s->phase - 1) % 8;
setPhase(s, s->phase);
}
void rotate(StepperBi *s, bool dir, int speed)
{
s->forward = dir;
s->speed = speed;
}
int main()
{
stdio_init_all();
StepperBi s1;
StepperBiInit(&s1, 18);
while (true)
{
stepForward(&s1);
sleep_ms(1);
}
return 0;
}
Page 178 remember to add hardware_pwm to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
typedef struct
{
uint gpio;
uint speed;
bool forward;
uint32_t gpiomask;
uint phase;
} StepperBi;
uint32_t stepTable[8] = (uint32_t[8]){0x8, 0xC, 0x4, 0x6, 0x2, 0x3, 0x1, 0x9};
/*
{1, 0, 0, 0},
{1, 1, 0, 0},
{0, 1, 0, 0},
{0, 1, 1, 0},
{0, 0, 1, 0},
{0, 0, 1, 1},
{0, 0, 0, 1},
{1, 0, 0, 1}
*/
void StepperBiInit(StepperBi *s, uint gpio)
{
s->gpio = gpio;
for (int i = 0; i < 4; i++)
{
gpio_set_function((s->gpio) + i, GPIO_FUNC_SIO);
gpio_set_dir((s->gpio) + i, true);
}
s->gpiomask = 0x0F << gpio;
volatile uint32_t mask = stepTable[0] << gpio;
gpio_put_masked(s->gpiomask, mask);
s->phase = 0;
s->speed = 0;
s->forward = true;
}
void setPhase(StepperBi *s, uint p)
{
uint32_t mask = stepTable[p] << (s->gpio);
gpio_put_masked(s->gpiomask, mask);
}
void stepForward(StepperBi *s)
{
s->phase = (s->phase + 1) % 8;
setPhase(s, s->phase);
}
void stepReverse(StepperBi *s)
{
s->phase = (s->phase - 1) % 8;
setPhase(s, s->phase);
}
bool step(struct repeating_timer *t)
{
StepperBi *s = (StepperBi *)(t->user_data);
if (s->forward)
{
stepForward(s);
}
else
{
stepReverse(s);
}
return true;
}
struct repeating_timer timer;
void rotate(StepperBi *s, bool dir, int speed)
{
cancel_repeating_timer(&timer);
s->forward = dir;
if (speed == 0)
{
s->speed = 0;
return;
}
s->speed = 1000 * 1000 / (4 * speed);
add_repeating_timer_us(s->speed, step, s, &timer);
}
int main()
{
static StepperBi s1;
StepperBiInit(&s1, 18);
rotate(&s1, true, 250);
while (true)
{
rotate(&s1, true, 250);
sleep_ms(100);
rotate(&s1, true, 00);
sleep_ms(100);
}
return 0;
}
Page 189 remember to add hardware_spi to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/spi.h"
int main()
{
stdio_init_all();
spi_init(spi0, 500 * 1000);
gpio_set_function(4, GPIO_FUNC_SPI);
gpio_set_function(6, GPIO_FUNC_SPI);
gpio_set_function(7, GPIO_FUNC_SPI);
spi_set_format(spi0, 8, SPI_CPOL_0, SPI_CPHA_0, SPI_MSB_FIRST);
uint16_t wBuff[1] = {0xAA};
uint16_t rBuff[1];
int n = spi_write16_read16_blocking(spi0, wBuff, rBuff, 1);
spi_deinit(spi0);
printf(" %X %X %d ", wBuff[0], rBuff[0], n);
}
Page 196-197 remember to add hardware_spi to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/spi.h"
int main()
{
stdio_init_all();
spi_init(spi0, 500 * 1000);
spi_set_format(spi0, 8, SPI_CPOL_0, SPI_CPHA_0, SPI_MSB_FIRST);
gpio_set_function(16, GPIO_FUNC_SPI);
gpio_set_function(18, GPIO_FUNC_SPI);
gpio_set_function(19, GPIO_FUNC_SPI);
gpio_init(17);
gpio_set_dir(17, GPIO_OUT);
gpio_put(17, 1);
sleep_ms(1);
uint8_t wBuff[1] = {0xD0};
uint8_t rBuff[8];
gpio_put(17, 0);
sleep_us(1);
spi_write_blocking(spi0, wBuff, 1);
spi_read_blocking(spi0, 0, rBuff, 1);
sleep_us(1);
gpio_put(17, 1);
printf("Chip ID is 0x%x\n", rBuff[0]);
gpio_put(17, 0);
sleep_us(1);
wBuff[0] = 0xF2;
wBuff[1] = 0x1;
spi_write_blocking(spi0, wBuff, 2);
wBuff[0] = 0xF4;
wBuff[1] = 0x27;
spi_write_blocking(spi0, wBuff, 2);
gpio_put(17, 1);
sleep_us(1);
wBuff[0] = 0xF7;
gpio_put(17, 0);
sleep_us(1);
spi_write_blocking(spi0, wBuff, 1);
spi_read_blocking(spi0, 0, rBuff, 8);
sleep_us(1);
gpio_put(17, 1);
uint32_t pressure = ((uint32_t)rBuff[0] << 12) | ((uint32_t)rBuff[1] << 4) | (rBuff[2] >> 4);
uint32_t temperature = ((uint32_t)rBuff[3] << 12) | ((uint32_t)rBuff[4] << 4) | (rBuff[5] >> 4);
uint32_t humidity = (uint32_t)rBuff[6] << 8 | rBuff[7];
printf("Humidity = %d\n", humidity);
printf("Pressure = %d\n", pressure);
printf("Temp. = %d\n", temperature);
}
Page 203 remember to add hardware_adc to the CMakeLists.txt file
#include
#include "pico/stdlib.h"
#include "hardware/adc.h"
int main()
{
stdio_init_all();
adc_init();
adc_gpio_init(26);
adc_gpio_init(27);
while (1)
{
const float conversion_factor = 3.3f / (1 << 12);
adc_select_input(0);
uint16_t result = adc_read();
printf("Raw value 0: 0x%03x, voltage: %f V\n",
result, result * conversion_factor);
adc_select_input(1);
result = adc_read();
printf("Raw value 1: 0x%03x, voltage: %f V\n",
result, result * conversion_factor);
sleep_ms(500);
}
}
Page 205 remember to add hardware_adc to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/adc.h"
int main()
{
stdio_init_all();
adc_init();
adc_gpio_init(26);
adc_gpio_init(27);
adc_set_round_robin(0x03);
adc_fifo_setup(true, false, 0, false, false);
adc_run(true);
const float conversion_factor = 3.3f / (1 << 12);
while (1)
{
uint16_t result = adc_fifo_get();
printf("Raw value 0: 0x%03x, voltage: %f V\n", result, result * conversion_factor);
int level = adc_fifo_get_level();
printf("level: %d \n", level);
}
}
Page 211 remember to add hardware_spi to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/spi.h"
int main()
{
stdio_init_all();
spi_init(spi0, 500 * 1000);
spi_set_format(spi0, 8, SPI_CPOL_0, SPI_CPHA_0, SPI_MSB_FIRST);
gpio_set_function(16, GPIO_FUNC_SPI);
gpio_set_function(18, GPIO_FUNC_SPI);
gpio_set_function(19, GPIO_FUNC_SPI);
gpio_init(17);
gpio_set_dir(17, GPIO_OUT);
gpio_put(17, 1);
sleep_ms(1);
uint16_t wBuff[3] = {0x01, 0x80, 0x00};
uint16_t rBuff[3];
gpio_put(17, 0);
int n = spi_write16_read16_blocking(spi0, wBuff, rBuff, 3);
sleep_us(1);
gpio_put(17, 1);
int data = ((int)rBuff[1] & 0x03) << 8 | (int)rBuff[2];
float volts = (float)data * 3.3f / 1023.0f;
printf("%f V\n", volts);
}
Page 227 remember to add hardware_i2c to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/i2c.h"
int main()
{
stdio_init_all();
i2c_init(i2c0, 100 * 1000);
gpio_set_function(4, GPIO_FUNC_I2C);
gpio_set_function(5, GPIO_FUNC_I2C);
uint8_t buf[] = {0xE7};
i2c_write_blocking(i2c0, 0x40, buf, 1, false);
i2c_read_blocking(i2c0, 0x40, buf, 1, false);
printf("User Register = %X \r\n", buf[0]);
}
Page 228 remember to add hardware_i2c to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/i2c.h"
int main()
{
stdio_init_all();
i2c_init(i2c0, 100 * 1000);
gpio_set_function(4, GPIO_FUNC_I2C);
gpio_set_function(5, GPIO_FUNC_I2C);
uint8_t buf[4] = {0xE3};
i2c_write_blocking(i2c0, 0x40, buf, 1, true);
i2c_read_blocking(i2c0, 0x40, buf, 3, false);
uint8_t msb = buf[0];
uint8_t lsb = buf[1];
uint8_t check = buf[2];
printf("msb %d \n\r lsb %d \n\r checksum %d \n\r", msb, lsb, check);
};
Page 233 remember to add hardware_i2c to the CMakeLists.txt file
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/i2c.h"
uint8_t crcCheck(uint8_t msb, uint8_t lsb, uint8_t check)
{
uint32_t data32 = ((uint32_t)msb << 16) | ((uint32_t)lsb << 8) |
(uint32_t)check;
uint32_t divisor = 0x988000;
for (int i = 0; i < 16; i++)
{
if (data32 & (uint32_t)1 << (23 - i))
data32 ^= divisor;
divisor >>= 1;
};
return (uint8_t)data32;
}
int main()
{
stdio_init_all();
i2c_init(i2c0, 100 * 1000);
gpio_set_function(4, GPIO_FUNC_I2C);
gpio_set_function(5, GPIO_FUNC_I2C);
uint8_t buf[4] = {0xE3};
i2c_write_blocking(i2c0, 0x40, buf, 1, true);
i2c_read_blocking(i2c0, 0x40, buf, 3, false);
uint8_t msb = buf[0];
uint8_t lsb = buf[1];
uint8_t check = buf[2];
printf("msb %d \n\r lsb %d \n\r checksum %d \n\r", msb, lsb, check);
unsigned int data16 = ((unsigned int)msb << 8) | (unsigned int)(lsb & 0xFC);
printf("crc = %d\n\r", crcCheck(msb, lsb, check));
float temp = (float)(-46.85 + (175.72 * data16 / (float)65536));
printf("Temperature %f C \n\r", temp);
buf[0] = 0xF5;
i2c_write_blocking(i2c0, 0x40, buf, 1, true);
while (i2c_read_blocking(i2c0, 0x40, buf, 3, false) < 0)
{
sleep_ms(1);
};
msb = buf[0];
lsb = buf[1];
check = buf[2];
printf("msb %d \n\r lsb %d \n\r checksum %d \n\r", msb, lsb, check);
printf("crc = %d\n\r", crcCheck(msb, lsb, check));
data16 = ((unsigned int)msb << 8) | (unsigned int)(lsb & 0xFC);
float hum = -6 + (125.0 * (float)data16) / 65536;
printf("Humidity %f %% \n\r", hum);
}
Page 240
.program squarewave
set pindirs, 1 ; Set pin to output
again:
set pins, 1 ; Drive pin high
set pins, 0 ; Drive pin low
jmp again ; Set PC to label `again`
Page 241
cmake_minimum_required(VERSION 3.13)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
pico_sdk_init()
project(pioBlinky C CXX ASM)
add_executable(pio
pio.c
)
pico_generate_pio_header(pio ${CMAKE_CURRENT_LIST_DIR}/sqwave.pio)
target_link_libraries(pio pico_stdlib hardware_pio)
pico_add_extra_outputs(pio)
Page 243 remember to use the CMakeLists.txt file and the PIO program given earlier
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "sqwave.pio.h"
int main()
{
uint offset = pio_add_program(pio0, &squarewave_program);
uint sm = pio_claim_unused_sm(pio0, true);
pio_sm_config c = squarewave_program_get_default_config(offset);
sm_config_set_set_pins(&c, 2, 1);
pio_gpio_init(pio0, 2);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
return 0;
}
Page 247
PIO Program
.program squarewave
set pindirs, 1
pull block
again:
set pins, 1
mov x, osr
loop1:
jmp x--,loop1
set pins, 0
mov x, osr
loop2:
jmp x--,loop2
jmp again
C Program
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "sqwave.pio.h"
int main()
{
uint offset = pio_add_program(pio0, &squarewave_program);
uint sm = pio_claim_unused_sm(pio0, true);
pio_sm_config c = squarewave_program_get_default_config(offset);
sm_config_set_set_pins(&c, 2, 1);
pio_gpio_init(pio0, 2);
sm_config_set_clkdiv_int_frac(&c, 255, 0);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
pio_sm_put_blocking(pio0, sm, 0xFFFF);
return 0;
}
Page 249-250
PIO Program
.program squarewave
set pindirs, 3
pull block
again:
out pins,2
jmp again
C Program
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "sqwave.pio.h"
int main()
{
uint offset = pio_add_program(pio0, &squarewave_program);
uint sm = pio_claim_unused_sm(pio0, true);
pio_sm_config c = squarewave_program_get_default_config(offset);
sm_config_set_set_pins(&c, 2, 2);
sm_config_set_out_pins(&c, 2, 2);
pio_gpio_init(pio0, 2);
pio_gpio_init(pio0, 3);
sm_config_set_clkdiv_int_frac(&c, 255, 0);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
pio_sm_put_blocking(pio0, sm, 0xFEDCBA98);
return 0;
}
Page 251-252
PIO Program
.program squarewave
again:
out pins,2
jmp again
C Program
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "sqwave.pio.h"
int main()
{
uint offset = pio_add_program(pio0, &squarewave_program);
uint sm = pio_claim_unused_sm(pio0, true);
pio_sm_config c = squarewave_program_get_default_config(offset);
sm_config_set_set_pins(&c, 2, 2);
sm_config_set_out_pins(&c, 2, 2);
pio_gpio_init(pio0, 2);
pio_gpio_init(pio0, 3);
pio_sm_set_consecutive_pindirs(pio0, sm, 2, 2, true);
sm_config_set_clkdiv_int_frac(&c, 255, 0);
sm_config_set_out_shift(&c, true, true, 6);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
while (true)
{
pio_sm_put_blocking(pio0, sm, 0xFEDCBA98);
}
return 0;
}
Page 253-254
PIO Program
.program squarewave
.side_set 1 opt
again:
nop side 1
jmp again side 0
C Program
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "sqwave.pio.h"
int main()
{
uint offset = pio_add_program(pio0, &squarewave_program);
uint sm = pio_claim_unused_sm(pio0, true);
pio_sm_config c = squarewave_program_get_default_config(offset);
sm_config_set_sideset_pins(&c, 2);
pio_gpio_init(pio0, 2);
pio_sm_set_consecutive_pindirs(pio0, sm, 2, 1, true);
sm_config_set_clkdiv_int_frac(&c, 255, 0);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
return 0;
}
Page 256-257
PIO Program
.program light
again:
in pins,1
push block
jmp again
C Program
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "light.pio.h"
int main()
{
uint offset = pio_add_program(pio0, &light_program);
uint sm = pio_claim_unused_sm(pio0, true);
pio_sm_config c = light_program_get_default_config(offset);
sm_config_set_in_pins(&c, 2);
pio_gpio_init(pio0, 2);
pio_sm_set_consecutive_pindirs(pio0, sm, 2, 1, false);
sm_config_set_clkdiv_int_frac(&c, 255, 0);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
gpio_init(25);
gpio_set_dir(25, GPIO_OUT);
while (true)
{
uint32_t flag = pio_sm_get_blocking(pio0, sm);
if (flag == 0)
{
gpio_put(25, 0);
}
else
{
gpio_put(25, 1);
}
}
return 0;
}
Page 258-259
PIO Program
.program squarewave
again:
wait 0 pin 0
wait 1 pin 0
set pins, 1
set pins, 0
jmp again
CProgram
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "sqwave.pio.h"
int main()
{
uint offset = pio_add_program(pio0, &squarewave_program);
uint sm = pio_claim_unused_sm(pio0, true);
pio_sm_config c = squarewave_program_get_default_config(offset);
sm_config_set_set_pins(&c, 3, 1);
sm_config_set_in_pins(&c, 2);
pio_gpio_init(pio0, 2);
pio_gpio_init(pio0, 3);
pio_sm_set_consecutive_pindirs(pio0, sm, 2, 1, false);
pio_sm_set_consecutive_pindirs(pio0, sm, 3, 1, true);
sm_config_set_clkdiv_int_frac(&c, 255, 0);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
return 0;
}
Page 267
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
int main()
{
stdio_init_all();
gpio_init(2);
gpio_set_dir(2, GPIO_OUT);
gpio_put(2, 1);
sleep_ms(1);
gpio_put(2, 0);
sleep_ms(1);
gpio_set_dir(2, GPIO_IN);
return 0;
}
Page 270-271
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
inline static void WaitFallingEdge(uint gpio)
{
while (gpio_get(gpio) == 1)
{
};
while (gpio_get(gpio) == 0)
{
};
}
uint32_t getData(uint gpio)
{
uint32_t t2;
uint32_t data = 0;
uint32_t t1 = time_us_32();
for (int i = 0; i < 32; i++)
{
WaitFallingEdge(2);
t2 = time_us_32();
data = data << 1;
data = data | ((t2 - t1) > 100);
t1 = t2;
}
return data;
}
uint8_t getCheck(uint gpio)
{
uint8_t checksum = 0;
uint32_t t2;
uint32_t t1 = time_us_32();
for (int i = 0; i < 8; i++)
{
WaitFallingEdge(2);
t2 = time_us_32();
checksum = checksum << 1;
checksum = checksum | (t2 - t1) > 100;
t1 = t2;
}
return checksum;
}
void dhtInitalize(uint gpio)
{
gpio_init(gpio);
gpio_set_dir(gpio, GPIO_OUT);
gpio_put(gpio, 1);
sleep_ms(1);
gpio_put(gpio, 0);
sleep_ms(1);
gpio_set_dir(gpio, GPIO_IN);
for (int i = 0; i < 2; i++)
{
WaitFallingEdge(gpio);
}
}
typedef struct
{
float temperature;
float humidity;
bool error;
} dhtData;
void dhtread(uint gpio, dhtData *reading)
{
dhtInitalize(gpio);
uint32_t data = getData(gpio);
uint8_t checksum = getCheck(gpio);
uint8_t byte1 = (data >> 24 & 0xFF);
uint8_t byte2 = (data >> 16 & 0xFF);
uint8_t byte3 = (data >> 8 & 0xFF);
uint8_t byte4 = (data & 0xFF);
reading->error = (checksum != ((byte1 + byte2 + byte3 + byte4) & 0xFF));
reading->humidity = (float)((byte1 << 8) | byte2) / 10.0;
int neg = byte3 & 0x80;
byte3 = byte3 & 0x7F;
reading->temperature = (float)(byte3 << 8 | byte4) / 10.0;
if (neg > 0)
reading->temperature = -reading->temperature;
}
int main()
{
stdio_init_all();
printf("data^^^^^\n");
dhtData reading;
dhtread(2, &reading);
printf("Humidity= %f %\n", reading.humidity);
printf("Temperature= %f C\n", reading.temperature);
return 0;
}
Page 275-277
PIO Program
.program dht
set pins, 1
set pindirs, 1
again:
pull block
set pins, 0
mov x, osr
loop1:
jmp x--,loop1
set pindirs, 0
wait 1 pin 0
wait 0 pin 0
wait 1 pin 0
wait 0 pin 0
set y,31
bits:
wait 1 pin 0
set x, 0
loop2:
jmp x--,continue
continue: jmp pin,loop2
in x,4
jmp y--,bits
set y,7
check:
wait 1 pin 0
set x, 0
loop3:
jmp x--,continue2
continue2: jmp pin,loop3
in x,4
jmp y--,check
jmp again
C Program
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "hardware/pio.h"
#include "DHT.pio.h"
uint dhtInitalize(PIO pio, int gpio)
{
uint offset = pio_add_program(pio, &dht_program);
uint sm = pio_claim_unused_sm(pio, true);
pio_gpio_init(pio, gpio);
pio_sm_config c = dht_program_get_default_config(offset);
sm_config_set_clkdiv_int_frac(&c, 128, 0);
sm_config_set_set_pins(&c, gpio, 1);
sm_config_set_in_pins(&c, gpio);
sm_config_set_jmp_pin(&c, gpio);
sm_config_set_in_shift(&c, true, true, 32);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
return sm;
}
uint8_t getByte(PIO pio, uint sm)
{
uint32_t count = pio_sm_get_blocking(pio0, sm);
uint8_t byte = 0;
for (int i = 0; i < 8; i++)
{
byte = byte << 1;
if (((count >> i * 4) & 0x0F) > 8)
{
byte = byte | 1;
}
}
return byte;
}
typedef struct
{
float temperature;
float humidity;
bool error;
} dhtData;
void dhtread(PIO pio, uint sm, dhtData *reading)
{
pio_sm_put_blocking(pio, sm, 1000);
uint8_t byte1 = getByte(pio, sm);
uint8_t byte2 = getByte(pio, sm);
uint8_t byte3 = getByte(pio, sm);
uint8_t byte4 = getByte(pio, sm);
uint8_t checksum = getByte(pio, sm);
reading->error = (checksum == (byte1 + byte2 + byte3 + byte4) & 0xFF);
reading->humidity = (float)((byte1 << 8) | byte2) / 10.0;
int neg = byte3 & 0x80;
byte3 = byte3 & 0x7F;
reading->temperature = (float)(byte3 << 8 | byte4) / 10.0;
if (neg > 0)
reading->temperature = -reading->temperature;
}
int main()
{
stdio_init_all();
uint sm = dhtInitalize(pio0, 2);
dhtData reading;
dhtread(pio0, sm, &reading);
printf("Humidity= %f %\n", reading.humidity);
printf("Temperature= %f C\n", reading.temperature);
return 0;
}
Page 281-283
PIO Program.program dht
set pins, 1
set pindirs, 1
again:
pull block
set pins, 0
mov x, osr
loop1:
jmp x--,loop1
set pindirs, 0
wait 1 pin 0
wait 0 pin 0
wait 1 pin 0
wait 0 pin 0
set y,31
bits:
wait 1 pin 0 [25]
in pins,1
wait 0 pin 0
jmp y--,bits
set y,7
check:
wait 1 pin 0 [25]
in pins,1
wait 0 pin 0
jmp y--,check
push block
jmp again
C Program
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "hardware/pio.h"
#include "DHT.pio.h"
uint dhtInitalize(PIO pio, int gpio)
{
uint offset = pio_add_program(pio, &dht_program);
uint sm = pio_claim_unused_sm(pio, true);
pio_gpio_init(pio, gpio);
pio_sm_config c = dht_program_get_default_config(offset);
sm_config_set_clkdiv_int_frac(&c, 255, 0);
sm_config_set_set_pins(&c, gpio, 1);
sm_config_set_in_pins(&c, gpio);
sm_config_set_in_shift(&c, false, true, 32);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
return sm;
}
typedef struct
{
float temperature;
float humidity;
bool error;
} dhtData;
void dhtread(PIO pio, uint sm, dhtData *reading)
{
pio_sm_put_blocking(pio, sm, 500);
uint32_t data = pio_sm_get_blocking(pio0, sm);
uint8_t byte1 = (data >> 24 & 0xFF);
uint8_t byte2 = (data >> 16 & 0xFF);
uint8_t byte3 = (data >> 8 & 0xFF);
uint8_t byte4 = (data & 0xFF);
uint8_t checksum = pio_sm_get_blocking(pio0, sm) & 0xFF;
reading->error = (checksum != ((byte1 + byte2 + byte3 + byte4) & 0xFF));
reading->humidity = (float)((byte1 << 8) | byte2) / 10.0;
int neg = byte3 & 0x80;
byte3 = byte3 & 0x7F;
reading->temperature = (float)(byte3 << 8 | byte4) / 10.0;
if (neg > 0)
reading->temperature = -reading->temperature;
}
int main()
{
stdio_init_all();
uint sm = dhtInitalize(pio0, 2);
dhtData reading;
dhtread(pio0, sm, &reading);
printf("Humidity= %f %\n", reading.humidity);
printf("Temperature= %f C\n", reading.temperature);
return 0;
}
CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(dht C CXX ASM)
pico_sdk_init()
add_executable(dht
DHT.c
)
pico_generate_pio_header(dht ${CMAKE_CURRENT_LIST_DIR}/DHT.pio)
target_link_libraries(dht pico_stdlib hardware_pio)
pico_add_extra_outputs(dht)
Page 300-303
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
int presence(uint8_t pin)
{
gpio_set_dir(2, GPIO_OUT);
gpio_put(pin, 1);
sleep_ms(1);
gpio_put(pin, 0);
sleep_us(480);
gpio_set_dir(pin, GPIO_IN);
sleep_us(70);
int b = gpio_get(pin);
sleep_us(410);
return b;
}
void writeBit(uint8_t pin, int b)
{
int delay1, delay2;
if (b == 1)
{
delay1 = 6;
delay2 = 64;
}
else
{
delay1 = 60;
delay2 = 10;
}
gpio_set_dir(pin, GPIO_OUT);
gpio_put(pin, 0);
sleep_us(delay1);
gpio_set_dir(pin, GPIO_IN);
sleep_us(delay2);
}
void writeByte(uint8_t pin, int byte)
{
for (int i = 0; i < 8; i++)
{
if (byte & 1)
{
writeBit(pin, 1);
}
else
{
writeBit(pin, 0);
}
byte = byte >> 1;
}
}
uint8_t readBit(uint8_t pin)
{
gpio_set_dir(pin, GPIO_OUT);
gpio_put(pin, 0);
sleep_us(8);
gpio_set_dir(pin, GPIO_IN);
sleep_us(2);
uint8_t b = gpio_get(pin);
sleep_us(60);
return b;
}
int readByte(uint8_t pin)
{
int byte = 0;
int i;
for (i = 0; i < 8; i++)
{
byte = byte | readBit(pin) << i;
};
return byte;
}
int convert(uint8_t pin)
{
writeByte(pin, 0x44);
int i;
for (i = 0; i < 500; i++)
{
sleep_ms(10);
if (readBit(pin) == 1)
break;
}
return i;
}
uint8_t crc8(uint8_t *data, uint8_t len)
{
uint8_t i;
uint8_t j;
uint8_t temp;
uint8_t databyte;
uint8_t crc = 0;
for (i = 0; i < len; i++)
{
databyte = data[i];
for (j = 0; j < 8; j++)
{
temp = (crc ^ databyte) & 0x01;
crc >>= 1;
if (temp)
crc ^= 0x8C;
databyte >>= 1;
}
}
return crc;
}
float getTemperature(uint8_t pin)
{
if (presence(pin) == 1)
return -1000;
writeByte(pin, 0xCC);
if (convert(pin) == 500)
return -3000;
presence(pin);
writeByte(pin, 0xCC);
writeByte(pin, 0xBE);
int i;
uint8_t data[9];
for (i = 0; i < 9; i++)
{
data[i] = readByte(pin);
}
uint8_t crc = crc8(data, 9);
if (crc != 0)
return -2000;
int t1 = data[0];
int t2 = data[1];
int16_t temp1 = (t2 << 8 | t1);
float temp = (float)temp1 / 16;
return temp;
}
int main()
{
stdio_init_all();
gpio_init(2);
if (presence(2) == 1)
{
printf("No device \n");
}
float t;
for (;;)
{
do
{
t = getTemperature(2);
} while (t < -999);
printf("%f\r\n", t);
sleep_ms(500);
};
return 0;
}
Page 309-312
PIO Program
.program DS1820
.wrap_target
again:
pull block
mov x, osr
jmp !x, read
write: set pindirs, 1
set pins, 0
loop1:
jmp x--,loop1
set pindirs, 0 [31]
wait 1 pin 0 [31]
pull block
mov x, osr
bytes1:
pull block
set y, 7
set pindirs, 1
bit1:
set pins, 0 [1]
out pins,1 [31]
set pins, 1 [20]
jmp y--,bit1
jmp x--,bytes1
set pindirs, 0 [31]
jmp again
read:
pull block
mov x, osr
bytes2:
set y, 7
bit2:
set pindirs, 1
set pins, 0 [1]
set pindirs, 0 [5]
in pins,1 [10]
jmp y--,bit2
jmp x--,bytes2
.wrap
C Program
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "DS1820.pio.h"
uint8_t crc8(uint8_t *data, uint8_t len)
{
uint8_t i;
uint8_t j;
uint8_t temp;
uint8_t databyte;
uint8_t crc = 0;
for (i = 0; i < len; i++)
{
databyte = data[i];
for (j = 0; j < 8; j++)
{
temp = (crc ^ databyte) & 0x01;
crc >>= 1;
if (temp)
crc ^= 0x8C;
databyte >>= 1;
}
}
return crc;
}
void writeBytes(PIO pio, uint sm, uint8_t bytes[], int len)
{
pio_sm_put_blocking(pio, sm, 250);
pio_sm_put_blocking(pio, sm, len - 1);
for (int i = 0; i < len; i++)
{
pio_sm_put_blocking(pio, sm, bytes[i]);
}
}
void readBytes(PIO pio, uint sm, uint8_t bytes[], int len)
{
pio_sm_put_blocking(pio, sm, 0);
pio_sm_put_blocking(pio, sm, len - 1);
for (int i = 0; i < len; i++)
{
bytes[i] = pio_sm_get_blocking(pio, sm) >> 24;
}
}
float getTemperature(PIO pio, uint sm)
{
writeBytes(pio, sm, (uint8_t[]){0xCC, 0x44}, 2);
sleep_ms(1000);
writeBytes(pio, sm, (uint8_t[]){0xCC, 0xBE}, 2);
uint8_t data[9];
readBytes(pio, sm, data, 9);
uint8_t crc = crc8(data, 9);
if (crc != 0)
return -2000;
int t1 = data[0];
int t2 = data[1];
int16_t temp1 = (t2 << 8 | t1);
volatile float temp = (float)temp1 / 16;
return temp;
}
uint DS18Initalize(PIO pio, int gpio)
{
uint offset = pio_add_program(pio, &DS1820_program);
uint sm = pio_claim_unused_sm(pio, true);
pio_gpio_init(pio, gpio);
pio_sm_config c = DS1820_program_get_default_config(offset);
sm_config_set_clkdiv_int_frac(&c, 255, 0);
sm_config_set_set_pins(&c, gpio, 1);
sm_config_set_out_pins(&c, gpio, 1);
sm_config_set_in_pins(&c, gpio);
sm_config_set_in_shift(&c, true, true, 8);
pio_sm_init(pio0, sm, offset, &c);
pio_sm_set_enabled(pio0, sm, true);
return sm;
}
int main()
{
stdio_init_all();
uint sm = DS18Initalize(pio0, 2);
float t;
for (;;)
{
do
{
t = getTemperature(pio0, sm);
} while (t < -999);
printf("temperature %f\r\n", t);
sleep_ms(500);
};
return 0;
}
CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(ds18 C CXX ASM)
pico_sdk_init()
add_executable(ds18
DS1820.c
)
pico_generate_pio_header(ds18 ${CMAKE_CURRENT_LIST_DIR}/DS1820.pio)
target_link_libraries(ds18 pico_stdlib hardware_gpio hardware_pio)
pico_add_extra_outputs(ds18)
Page 322
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
int main()
{
stdio_init_all();
uart_init(uart1, 9600);
gpio_set_function(4, GPIO_FUNC_UART);
gpio_set_function(5, GPIO_FUNC_UART);
uart_set_format(uart1, 8, 1, UART_PARITY_EVEN);
uint8_t SendData[] = "Hello World";
uint8_t RecData[20];
uart_write_blocking(uart1, SendData, 11);
uart_read_blocking(uart1, RecData, 11);
RecData[11] = 0;
printf("%s", RecData);
}
Page 330
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "hardware/adc.h"
int main()
{
stdio_init_all();
adc_init();
adc_select_input(3);
uint16_t result = adc_read();
if (result < 0xFF) {
printf("Pico W\n");
}else{
printf("Pico\n");
};
}
Page 335
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
int setup(uint32_t country, const char *ssid, const char *pass, uint32_t auth)
{
if (cyw43_arch_init_with_country(country))
{
return 1;
}
cyw43_arch_enable_sta_mode();
if (cyw43_arch_wifi_connect_blocking(ssid, pass, auth))
{
return 2;
}
}
char ssid[] = "myhost";
char pass[] = "mypassword";
uint32_t country = CYW43_COUNTRY_mycountry;
uint32_t auth = CYW43_AUTH_WPA2_MIXED_PSK;
int main()
{
stdio_init_all();
setup(country, ssid, pass, auth);
while (true)
{
sleep_ms(1);
}
}
Page 336
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(picow
picow.c
)
target_include_directories(picow PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(picow pico_stdlib
pico_cyw43_arch_lwip_threadsafe_background)
pico_add_extra_outputs(picow)
Page 337
int setup(uint32_t country, const char *ssid, const char *pass, uint32_t auth)
{
if (cyw43_arch_init_with_country(country))
{
return 1;
}
cyw43_arch_enable_sta_mode();
if (cyw43_arch_wifi_connect_async(ssid, pass, auth))
{
return 2;
}
int flashrate = 1000;
int status = CYW43_LINK_UP + 1;
while (status >= 0 && status != CYW43_LINK_UP)
{
int new_status = cyw43_tcpip_link_status(&cyw43_state, CYW43_ITF_STA);
if (new_status != status)
{
status = new_status;
flashrate = flashrate / (status + 1);
printf("connect status: %d %d\n", status, flashrate);
}
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
sleep_ms(flashrate);
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
sleep_ms(flashrate);
}
if (status < 0)
{
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
}
else
{
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
}
return status;
}
Page 339-340
int setup(uint32_t country, const char *ssid, const char *pass,
uint32_t auth, const char *hostname, ip_addr_t *ip,
ip_addr_t *mask, ip_addr_t *gw)
{
if (cyw43_arch_init_with_country(country))
{
return 1;
}
cyw43_arch_enable_sta_mode();
if (hostname != NULL)
{
netif_set_hostname(netif_default, hostname);
}
if (cyw43_arch_wifi_connect_async(ssid, pass, auth))
{
return 2;
}
int flashrate = 1000;
int status = CYW43_LINK_UP + 1;
while (status >= 0 && status != CYW43_LINK_UP)
{
int new_status = cyw43_tcpip_link_status(&cyw43_state,
CYW43_ITF_STA);
if (new_status != status)
{
status = new_status;
flashrate = flashrate / (status + 1);
printf("connect status: %d %d\n", status, flashrate);
}
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
sleep_ms(flashrate);
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
sleep_ms(flashrate);
}
if (status < 0)
{
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
}
else
{
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
if (ip != NULL)
{
netif_set_ipaddr(netif_default, ip);
}
if (mask != NULL)
{
netif_set_netmask(netif_default, mask);
}
if (gw != NULL)
{
netif_set_gw(netif_default, gw);
}
printf("IP: %s\n",
ip4addr_ntoa(netif_ip_addr4(netif_default)));
printf("Mask: %s\n",
ip4addr_ntoa(netif_ip_netmask4(netif_default)));
printf("Gateway: %s\n",
ip4addr_ntoa(netif_ip_gw4(netif_default)));
printf("Host Name: %s\n",
netif_get_hostname(netif_default));
}
return status;
}
Page 346 - corrected to free pbuf see errata
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/apps/http_client.h"
char myBuff[1000];
void result(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, u32_t srv_res, err_t err)
{
printf("transfer complete\n");
printf("local result=%d\n", httpc_result);
printf("http result=%d\n", srv_res);
}
err_t headers(httpc_state_t *connection, void *arg, struct pbuf *hdr, u16_t hdr_len, u32_t content_len)
{
printf("headers recieved\n");
printf("content length=%d\n", content_len);
printf("header length %d\n", hdr_len);
pbuf_copy_partial(hdr, myBuff, hdr->tot_len, 0);
printf("headers \n");
printf("%s", myBuff);
return ERR_OK;
}
err_t body(void *arg, struct altcp_pcb *conn, struct pbuf *p, err_t err)
{
printf("body\n");
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
printf("%s", myBuff);
return ERR_OK;
}
char ssid[] = "mySSID";
char pass[] = "myPassword";
uint32_t country = CYW43_COUNTRY_mycountry;
uint32_t auth = CYW43_AUTH_WPA2_MIXED_PSK;
int main()
{
stdio_init_all();
setup(country, ssid, pass, auth, "MyPicoW", NULL, NULL, NULL);
uint16_t port = 80;
httpc_connection_t settings;
settings.result_fn = result;
settings.headers_done_fn = headers;
err_t err = httpc_get_file_dns(
"example.com",
80,
"/index.html",
&settings,
body,
NULL,
NULL);
printf("status %d \n", err);
while (true)
{
sleep_ms(500);
}
}
void result(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, u32_t srv_res, err_t err)
{
printf("transfer complete\n");
printf("local result=%d\n", httpc_result);
printf("http result=%d\n", srv_res);
}
err_t headers(httpc_state_t *connection, void *arg, struct pbuf *hdr, u16_t hdr_len, u32_t content_len)
{
printf("headers recieved\n");
printf("content length=%d\n", content_len);
printf("header length %d\n", hdr_len);
pbuf_copy_partial(hdr, myBuff, hdr->tot_len, 0);
printf("headers \n");
printf("%s", myBuff);
return ERR_OK;
}
err_t body(void *arg, struct altcp_pcb *conn, struct pbuf *p, err_t err)
{
printf("body\n");
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
pbuf_free(p);
printf("%s", myBuff);
return ERR_OK;
}
char ssid[] = "mySSID";
char pass[] = "myPassword";
uint32_t country = CYW43_COUNTRY_mycountry;
uint32_t auth = CYW43_AUTH_WPA2_MIXED_PSK;
int main()
{
stdio_init_all();
setup(country, ssid, pass, auth, "MyPicoW", NULL, NULL, NULL);
uint16_t port = 80;
httpc_connection_t settings;
settings.result_fn = result;
settings.headers_done_fn = headers;
err_t err = httpc_get_file_dns(
"example.com",
80,
"/index.html",
&settings,
body,
NULL,
NULL);
printf("status %d \n", err);
while (true)
{
sleep_ms(500);
}
}
Page 347
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/apps/httpd.h"
char ssid[] = "myssid";
char pass[] = "mypassword";
uint32_t country = CYW43_COUNTRY_mycountry;
uint32_t auth = CYW43_AUTH_WPA2_MIXED_PSK;
int main()
{
stdio_init_all();
setup(country, ssid, pass, auth, "MyPicoW", NULL, NULL, NULL);
httpd_init();
while (true)
{
sleep_ms(500);
}
}
Page 349
cmake_minimum_required(VERSION 3.13)
project(makefsdata C CXX ASM)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
add_executable(htmlgen
makefsdata.c
)
target_include_directories(htmlgen
PRIVATE ../../../../src/include/
PRIVATE ../../../../contrib/ports/unix/port/include/
PRIVATE ${CMAKE_CURRENT_LIST_DIR})
Page 354
C File
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/apps/httpd.h"
int setup(uint32_t country, const char *ssid, const char *pass, uint32_t auth, const char *hostname, ip_addr_t *ip, ip_addr_t *mask, ip_addr_t *gw)
{
if (cyw43_arch_init_with_country(country))
{
return 1;
}
cyw43_arch_enable_sta_mode();
if (hostname != NULL)
{
netif_set_hostname(netif_default, hostname);
}
if (cyw43_arch_wifi_connect_async(ssid, pass, auth))
{
return 2;
}
int flashrate = 1000;
int status = CYW43_LINK_UP + 1;
while (status >= 0 && status != CYW43_LINK_UP)
{
int new_status = cyw43_tcpip_link_status(&cyw43_state, CYW43_ITF_STA);
if (new_status != status)
{
status = new_status;
flashrate = flashrate / (status + 1);
printf("connect status: %d %d\n", status, flashrate);
}
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
sleep_ms(flashrate);
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
sleep_ms(flashrate);
}
if (status < 0)
{
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
}
else
{
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
if (ip != NULL)
{
netif_set_ipaddr(netif_default, ip);
}
if (mask != NULL)
{
netif_set_netmask(netif_default, mask);
}
if (gw != NULL)
{
netif_set_gw(netif_default, gw);
}
printf("IP: %s\n", ip4addr_ntoa(netif_ip_addr4(netif_default)));
printf("Mask: %s\n", ip4addr_ntoa(netif_ip_netmask4(netif_default)));
printf("Gateway: %s\n", ip4addr_ntoa(netif_ip_gw4(netif_default)));
printf("Host Name: %s\n", netif_get_hostname(netif_default));
}
return status;
}
const char *ssitags[] = {"temp", "hum"};
u16_t mySSIHandler(int iIndex, char *pcInsert, int iInsertLen)
{
switch (iIndex)
{
case 0:
snprintf(pcInsert, iInsertLen, "42 C");
break;
case 1:
snprintf(pcInsert, iInsertLen, "80%%");
break;
}
}
char ssid[] = "mySSDI";
char pass[] = "myPassword";
uint32_t country = CYW43_COUNTRY_mycountry;
uint32_t auth = CYW43_AUTH_WPA2_MIXED_PSK;
int main()
{
stdio_init_all();
setup(country, ssid, pass, auth, "MyPicoW", NULL, NULL, NULL);
http_set_ssi_handler(mySSIHandler, ssitags, 2);
httpd_init();
while (true)
{
sleep_ms(500);
}
}
CMAKE file
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(picow
picow.c
)
target_include_directories(picow PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(picow pico_stdlib
pico_cyw43_arch_lwip_threadsafe_background pico_lwip_http)
pico_add_extra_outputs(picow)
Page 363
#include "pico/stdlib.h"
#include "hardware/gpio.h"
int main()
{
gpio_init(25);
gpio_set_dir(25, GPIO_OUT);
uint32_t *SIO = (uint32_t *)0xd0000000;
while (true)
{
*(SIO + 0x014 / 4) = 1ul << 25;
sleep_ms(500);
*(SIO + 0x018 / 4) = 1ul << 25;
sleep_ms(500);
}
}
Programming the Raspberry Pi Pico/W in MicroPython
We have decided not to make the programs available as a download because this is not the point of the book - the programs are not finished production code but something you should type in and study.
The best solution is to provide the source code of the programs in a form that can be copied and pasted into Thonny or VS Code project.
The only downside is that you have to create a project to paste the code into.
To do this follow the instructions in the book.
All of the programs below were copy and pasted from working programs in the IDE. They have been formatted using the built in formatter and hence are not identical in layout to the programs in the book. This is to make copy and pasting them easier. The programs in the book are formatted to be easy to read on the page.
If anything you consider important is missing or if you have any requests or comments contact:
This email address is being protected from spambots. You need JavaScript enabled to view it.
Page 32
from machine import Pin
import time
pin = Pin("LED", Pin.OUT)
while True:
pin.value(1)
time.sleep(1)
pin.value(0)
time.sleep(1)
Page 32
from machine import Pin
import time
pin = Pin(22, Pin.OUT)
while True:
pin.value(1)
time.sleep(1)
pin.value(0)
time.sleep(1)
Page 38
from machine import Pin
import time
pin = Pin(22,Pin.OUT)
while True:
pin.toggle()
time.sleep(1)
Page 38
from machine import Pin
def flash():
pin = Pin(22, Pin.OUT)
while True:
pin.value(1)
pin.value(0)
flash()
Page 39
from machine import Pin
@micropython.native
def flash():
pin = Pin(22, Pin.OUT)
while True:
pin.value(1)
pin.value(0)
flash()
Page 40
from machine import Pin
import time
pin = Pin(22, Pin.OUT)
while True:
pin.value(1)
time.sleep(0.5)
pin.value(0)
time.sleep(0.5)
Page 40
from machine import Pin
import time
pin = Pin(22, Pin.OUT)
while True:
pin.value(1)
time.sleep_us(10)
pin.value(0)
time.sleep_us(10)
Page 40
from machine import Pin
import time
pin = Pin(22, Pin.OUT)
n = 10
while True:
for i in range(n):
pass
pin.value(1)
for i in range(n):
pass
pin.value(0)
Page 42
from machine import Pin
pin1 = Pin(21, Pin.OUT)
pin2 = Pin(22, Pin.OUT)
while True:
pin1.value(1)
pin2.value(0)
pin1.value(0)
pin2.value(1)
Page 44
from machine import Pin
import machine
def gpio_get():
return machine.mem32[0xd0000000+0x010]
def gpio_set(value, mask):
machine.mem32[0xd0000000 + 0x01C] = (machine.mem32[0xd0000000+0x010]) ^ value & mask
pin = Pin(22, Pin.OUT)
pin = Pin(21, Pin.OUT)
value1 = 1 << 22 | 0 << 21
value2 = 0 << 22 | 1 << 21
mask = 1 << 22 | 1 << 21
while True:
gpio_set(value1, mask)
gpio_set(value2, mask)
Page 65
from machine import Pin
import time
pinIn = Pin(22, Pin.IN,Pin.PULL_UP)
pinLED = Pin(25, Pin.OUT)
while True:
if pinIn.value():
pinLED.on()
else:
pinLED.off()
time.sleep(0.5)
Page 66
from machine import Pin
import time
pinIn = Pin(22, Pin.IN, Pin.PULL_DOWN)
pinLED = Pin(25, Pin.OUT)
while True:
while pinIn.value() == 0:
pass
while pinIn.value() == 1:
pass
pinLED.on()
time.sleep(1)
pinLED.off()
Page 67
from machine import Pin
import time
pinIn = Pin(22, Pin.IN, Pin.PULL_DOWN)
pinLED = Pin(25, Pin.OUT)
while True:
while pinIn.value() == 0:
pass
t = time.ticks_ms()
time.sleep_ms(1)
while pinIn.value() == 1:
pass
t = time.ticks_diff(time.ticks_ms(), t)
if t < 2000:
pinLED.on()
time.sleep(1)
pinLED.off()
else:
for i in range(10):
pinLED.on()
time.sleep_ms(100)
pinLED.off()
time.sleep_ms(100)
Page 68
from machine import Pin
import time
pinIn = Pin(22, Pin.IN)
while True:
while pinIn.value() == 1:
pass
while pinIn.value() == 0:
pass
t = time.ticks_us()
while pinIn.value() == 1:
pass
t = time.ticks_diff(time.ticks_us(), t)
print(t)
time.sleep(1)
Page 69
import time
import machine
pinIn = machine.Pin(22, machine.Pin.IN)
while True:
t = machine.time_pulse_us(pinIn, 1)
print(t)
time.sleep(1)
Page 69
import machine
import time
import machine
pinIn = machine.Pin(22, machine.Pin.IN)
while True:
while pinIn.value() == 1:
pass
t = machine.time_pulse_us(pinIn, 1)
print(t)
time.sleep(1)
Page 72
from machine import Pin
import time
pinIn = Pin(22, Pin.IN)
s = 0
count = 0
while True:
i = pinIn.value()
t = time.ticks_add(time.ticks_us(), 1000*100)
if s == 0: # button not pushed
if i:
s = 1
count = count+1
print("Button Push ", count)
elif s == 1: # button pushed
if not i:
s = 0
else:
s = 0
while time.ticks_us() < t:
pass
Page 74
from machine import Pin
import time
pinIn = Pin(22, Pin.IN)
s = 0
while True:
i = pinIn.value()
t = time.ticks_add(time.ticks_us(), 1000*100)
if s == 0: # button not pushed
if i:
s = 1
tpush = t
elif s == 1: # button pushed
if not i:
s = 0
if time.ticks_diff(t, tpush) > 2000000:
print("Button held \n\r")
else:
print("Button pushed \n\r")
else:
s = 0
while time.ticks_us() < t:
pass
Page 75
from machine import Pin
import time
pinIn = Pin(22, Pin.IN)
pinLED1 = Pin(21, Pin.OUT)
pinLED2 = Pin(20, Pin.OUT)
pinLED3 = Pin(19, Pin.OUT)
pinLED1.on()
pinLED2.off()
pinLED3.off()
s = 0
buttonState = pinIn.value()
while True:
buttonNow = pinIn.value()
edge = buttonState-buttonNow
buttonState = buttonNow
t = time.ticks_add(time.ticks_us(), 1000*100)
if s == 0:
if edge == 1:
s = 1
pinLED1.off()
pinLED2.on()
pinLED3.off()
elif s == 1:
if edge == 1:
s = 2
pinLED1.off()
pinLED2.off()
pinLED3.on()
elif s == 2:
if edge == 1:
s = 0
pinLED1.on()
pinLED2.off()
pinLED3.off()
else:
s = 0
while time.ticks_us() < t:
pass
Page 83
from utime import sleep
from machine import Pin
import machine
def gpio_get_events(pinNo):
mask = 0xF << 4 * (pinNo % 8)
intrAddr = 0x40014000 + 0x0f0 + (pinNo // 8)*4
return (machine.mem32[intrAddr] & mask) >> (4 * (pinNo % 8))
def gpio_clear_events(pinNo, events):
intrAddr = 0x40014000 + 0x0f0 + (pinNo // 8)*4
machine.mem32[intrAddr] = events << (4 * (pinNo % 8))
pin = Pin(22, Pin.IN, Pin.PULL_UP)
while True:
event = gpio_get_events(22)
if(event & Pin.IRQ_FALLING):
print("falling")
if(event & Pin.IRQ_RISING):
print("rising")
gpio_clear_events(22, Pin.IRQ_FALLING | Pin.IRQ_RISING)
sleep(0.5)
Page 83
from utime import sleep
from machine import Pin
pin = Pin(22, Pin.IN, Pin.PULL_DOWN)
print("Press Button")
sleep(10)
if pin.value():
print("Button Pressed")
else:
print("Button Not Pressed")
Page 84
from utime import sleep
from machine import Pin
import machine
def gpio_get_events(pinNo):
mask = 0xF << 4 * (pinNo % 8)
intrAddr = 0x40014000 + 0x0f0 + (pinNo // 8)*4
return (machine.mem32[intrAddr] & mask) >> (4 * (pinNo % 8))
def gpio_clear_events(pinNo, events):
intrAddr = 0x40014000 + 0x0f0 + (pinNo // 8)*4
machine.mem32[intrAddr] = events << (4 * (pinNo % 8))
pin = Pin(22, Pin.IN, Pin.PULL_DOWN)
print("Press Button")
gpio_clear_events(22, Pin.IRQ_FALLING)
sleep(10)
event = gpio_get_events(22)
gpio_clear_events(22, Pin.IRQ_FALLING)
if event & Pin.IRQ_FALLING:
print("Button Pressed")
else:
print("Button Not Pressed")
Page 85
import time
from utime import sleep
from machine import Pin
import machine
def gpio_get_events(pinNo):
mask = 0xF << 4 * (pinNo % 8)
intrAddr = 0x40014000 + 0x0f0 + (pinNo // 8)*4
return (machine.mem32[intrAddr] & mask) >> (4 * (pinNo % 8))
def gpio_clear_events(pinNo, events):
intrAddr = 0x40014000 + 0x0f0 + (pinNo // 8)*4
machine.mem32[intrAddr] = events << (4 * (pinNo % 8))
pin = Pin(22, Pin.IN, Pin.PULL_DOWN)
while True:
gpio_clear_events(22, Pin.IRQ_FALLING | Pin.IRQ_RISING)
while not(gpio_get_events(22) & Pin.IRQ_RISING):
pass
t = time.ticks_us()
while not(gpio_get_events(22) & Pin.IRQ_FALLING):
pass
t = time.ticks_diff(time.ticks_us(), t)
print(t)
sleep(1)
Page 88
import time
from machine import Pin
import machine
import array
count = 0
t = array.array('L', [0]*20)
def myHandler(pin):
global t, count
t[count] = time.ticks_us()
count = count+1
if count > 19:
for i in range(1, 20):
print(time.ticks_diff(t[i], t[i-1]))
pin.irq(None, Pin.IRQ_RISING, hard=True)
return
pin = Pin(22, Pin.IN, Pin.PULL_DOWN)
pin.irq(myHandler, Pin.IRQ_RISING, hard=False)
Page 90
import time
from machine import Pin
def myHandler(pin):
print(time.ticks_us())
pin = Pin(22, Pin.IN, Pin.PULL_DOWN)
pin.irq(myHandler, Pin.IRQ_RISING, hard=True)
while True:
print("doing something useful")
Page 96
from machine import Pin, PWM
pwm16 = PWM(Pin(16))
pwm17 = PWM(Pin(17))
pwm16.freq(250)
pwm16.duty_u16(65535//2)
pwm17.duty_u16(65535//4)
Page 97
from machine import Pin, PWM
import machine
def pwm_set_phase(sliceNo, phase):
Addr = 0x40050000 + 0x14*sliceNo
if phase:
machine.mem32[Addr] = machine.mem32[Addr] | 0x2
else:
machine.mem32[Addr] = machine.mem32[Addr] & 0xFFFFFFFD
pwm16 = PWM(Pin(16))
pwm17 = PWM(Pin(17))
pwm16.freq(250)
pwm_set_phase(0, True)
pwm16.duty_u16(65535//2)
pwm17.duty_u16(65535//4)
Page 98
from machine import Pin, PWM
def pwm_set_polarity(sliceNo, channel, invert):
Addr = 0x40050000 + 0x14*sliceNo
if invert:
machine.mem32[Addr] = machine.mem32[Addr] | 0x1 << (2+channel)
else:
machine.mem32[Addr] = machine.mem32[Addr] & ~(0x1 << (2+channel))
pwm16 = PWM(Pin(16))
pwm17 = PWM(Pin(17))
pwm16.freq(250)
pwm_set_polarity(0, 1, True)
pwm16.duty_u16(65535//4)
pwm17.duty_u16(65535//4)
Page 99
from machine import Pin, PWM
pwm16 = PWM(Pin(16))
pwm16.freq(50)
pwm16.duty_u16(65535//2)
while True:
pwm16.duty_u16(65535//2)
pwm16.duty_u16(65535//4)
Page 101
from machine import Pin, PWM
import array
import machine
import math
def pwm_get_wrap(sliceNo):
Addr = 0x40050000 + 0x10+0x14*sliceNo
return (machine.mem32[Addr])
wave = array.array('H', [0]*256)
for i in range(256):
wave[i] = int(65535//2 + (math.sin(i * 2.0 * 3.14159 / 256.0) * 65535//2))
pwm16 = PWM(Pin(16))
pwm16.freq(125000000//256)
print(pwm_get_wrap(0))
while(True):
for i in range(256):
pwm16.duty_u16(wave[i])
Page 103
from utime import sleep_ms
from machine import Pin, PWM
pwm25 = PWM(Pin(25))
pwm25.freq(2000)
while True:
for d in range(0,65535,655):
pwm25.duty_u16(d)
sleep_ms(50)
Page 105
from utime import sleep_ms
from machine import Pin, PWM
pwm25 = PWM(Pin(25))
pwm25.freq(2000)
while True:
for b in range(0,100):
pwm25.duty_u16(int(65535*b*b*b/1000000))
sleep_ms(50)
Page 115
from machine import Pin, PWM
from time import sleep
class Motor:
def __init__(self, pinNo):
self.gpio = pinNo
self._on = False
self.speed=0
self.pwm1=PWM(Pin(pinNo))
self.pwm1.freq(2000)
self.pwm1.duty_u16(0)
def setSpeed(self,s):
self._on=True
self.speed=s
self.pwm1.duty_u16(int(65535*s/100))
def off(self):
self._on=False
self.pwm1.duty_u16(0)
def on(self):
self._on=True
self.pwm1.duty_u16(int(65535*self.speed/100))
motor=Motor(16)
motor.setSpeed(50)
sleep(1)
motor.off()
sleep(1)
motor.setSpeed(90)
sleep(1)
motor.off()
Page 120
from machine import Pin, PWM
from time import sleep
class Motor:
def __init__(self, pinNo):
self.gpio = pinNo
self._on = False
self.speed=0
self.pwm1=PWM(Pin(pinNo))
self.pwm1.freq(2000)
self.pwm1.duty_u16(0)
def setSpeed(self,s):
self._on=True
self.speed=s
self.pwm1.duty_u16(int(65535*s/100))
def off(self):
self._on=False
self.pwm1.duty_u16(0)
def on(self):
self._on=True
self.pwm1.duty_u16(int(65535*self.speed/100))
class BiMotor(Motor):
def __init__(self, pinNo):
super().__init__(pinNo)
self.forward=True
self.pwm2=PWM(Pin(pinNo+1))
self.pwm2.duty_u16(0)
def setForward(self,forward):
if self.forward==forward:
return
self.pwm1.duty_u16(0)
self.pwm1,self.pwm2=self.pwm2,self.pwm1
self.forward=forward
self.pwm1.duty_u16(int(65535*self.speed/100))
motor=BiMotor(16)
motor.setSpeed(50)
sleep(1)
motor.setForward(False)
sleep(1)
motor.setSpeed(90)
sleep(1)
motor.setForward(True)
motor.off()
Page 123
from machine import Pin, PWM
from time import sleep
class Servo:
def __init__(self, pinNo):
self.pwm = PWM(Pin(pinNo))
self.pwm.freq(50)
self.position = 65535*2.5/100
def setPosition(self, p):
self.position = p
self.pwm.duty_u16(int(65535*p/1000 + 65535*2.5/100))
servo=Servo(16)
servo.setPosition(100.0)
sleep(1)
servo.setPosition(50.0)
sleep(1)
servo.setPosition(0)
Page 124-125
from machine import Pin, PWM
import machine
from time import sleep
class Servo:
def __init__(self, pinNo):
self.pwm = PWM(Pin(pinNo))
self.pin = pinNo
self.pwm.freq(50)
self.position = 65535*2.5/100
def setPosition(self, p):
self.position = p
self.pwm.duty_u16(int(65535*p/1000 + 65535*2.5/100))
def getSlice(self):
return (self.pin >> 1) & 0x07
def getChannel(self):
return self.pin & 1
def setPolarity(self, invert):
sliceNo = self.getSlice()
channel = self.getChannel()
Addr = 0x40050000 + 0x14*sliceNo
if invert:
machine.mem32[Addr] = machine.mem32[Addr] | 0x1 << (2+channel)
else:
machine.mem32[Addr] = machine.mem32[Addr] & ~(0x1 << (2+channel))
servo = Servo(16)
servo.setPolarity(True)
servo.setPosition(100.0)
sleep(1)
servo.setPosition(50.0)
sleep(1)
servo.setPosition(0)
Page 136
from utime import sleep_ms
from machine import Pin
import machine
class StepperBi4():
def __init__(self, pinA):
self.phase = 0
self.pinA = pinA
self.timer = None
self.forward = True
self.speed = 0
self.gpios = tuple([Pin(pinA, Pin.OUT), Pin(
pinA+1, Pin.OUT), Pin(pinA+2, Pin.OUT), Pin(pinA+3, Pin.OUT)])
self.gpios[0].high()
self.gpioMask = 0xF << self.pinA
self.halfstepSeq = [0x1, 0x3, 0x2, 0x6, 0x4, 0xC, 0x8, 0x9]
# [
# [0,0,0,1],
# [0,0,1,1],
# [0,0,1,0],
# [0,1,1,0],
# [0,1,0,0],
# [1,1,0,0],
# [1,0,0,0],
# [1,0,0,1]
# ]
def _gpio_set(self, value, mask):
machine.mem32[0xd0000000 +
0x01C] = (machine.mem32[0xd0000000+0x010] ^ value) & mask
def setPhase(self, phase):
value = self.halfstepSeq[phase] << self.pinA
self._gpio_set(value, self.gpioMask)
self.phase = phase
def stepForward(self):
self.phase = (self.phase+1) % 8
self.setPhase(self.phase)
def stepReverse(self):
self.phase = (self.phase-1) % 8
self.setPhase(self.phase)
def doRotate(self, timer):
if self.forward:
self.stepForward()
else:
self.stepReverse()
def rotate(self, forward, speed):
self.forward = forward
self.speed = speed
if speed == 0:
self.timer.deinit()
self.timer = None
return
if self.timer == None:
self.timer = machine.Timer()
self.timer.init(freq=speed, mode=machine.Timer.PERIODIC,
callback=self.doRotate)
step = StepperBi4(16)
step.setPhase(0)
while True:
step.rotate(True, 100)
sleep_ms(500)
step.rotate(True, 0)
sleep_ms(500)
Page 147
from machine import Pin, SPI
spi = SPI(0, sck=Pin(6), miso=Pin(4), mosi=Pin(7))
spi.init(baudrate=500_000, bits=8, polarity=0, phase=0, firstbit=SPI.MSB)
read = bytearray(3)
write = bytearray([0xAA, 0xAA, 0xAA])
spi.write_readinto(write, read)
print(read, write)
spi.deinit()
Page 152
from utime import sleep_ms
from machine import Pin, SPI
from time import sleep
spi = SPI(0, sck=Pin(18), miso=Pin(16), mosi=Pin(19))
spi.init(baudrate=500_000, bits=8, polarity=0, phase=0, firstbit=SPI.MSB)
CS = Pin(17, Pin.OUT)
CS.high()
sleep_ms(1)
write = bytearray([0xD0])
CS.low()
spi.write(write)
read = spi.read(1)
CS.high()
print("Chip ID is", hex(read[0]))
CS.low()
write = bytearray([0xF2, 0x01])
spi.write(write)
write = bytearray([0xF4, 0x27])
spi.write(write)
CS.high()
CS.low()
write = bytearray([0xF7])
spi.write(write)
sleep_ms(10)
rBuff = spi.read(8)
CS.high()
pressure = (rBuff[0] << 12) | (rBuff[1] << 4) | (rBuff[2] >> 4)
temperature = (rBuff[3] << 12) | (rBuff[4] << 4) | (rBuff[5] >> 4)
humidity = rBuff[6] << 8 | rBuff[7]
print("Humidity = ", humidity)
print("Pressure = ", pressure)
print("Temp. = ", temperature)
Page 157
import machine
import utime
sensor_temp = machine.ADC(4)
conversion_factor = 3.3 / (65535)
while True:
reading = sensor_temp.read_u16() * conversion_factor
temperature = 27 - (reading - 0.706)/0.001721
print(temperature)
utime.sleep(2)
Page 163
from utime import sleep_ms
from machine import Pin, SPI
from time import sleep
spi = SPI(0, sck=Pin(18), miso=Pin(16), mosi=Pin(19))
spi.init(baudrate=500_000, bits=8, polarity=0, phase=0, firstbit=SPI.MSB)
CS = Pin(17, Pin.OUT)
CS.high()
sleep_ms(1)
CS.low()
write = bytearray([0x01, 0x80, 0x00])
read = bytearray(3)
spi.write_readinto(write, read)
CS.high()
data = (read[1] & 0x03) << 8 | read[2]
volts = data * 3.3 / 1023.0
print(volts)
spi.deinit()
Page 163
from utime import sleep_ms
from machine import Pin, SPI
from time import sleep
class spiADC:
def __init__(self, spi, sckNo, misoNo, mosiNo, CSNo):
self.spi = SPI(spi, sck=Pin(sckNo), miso=Pin(misoNo), mosi=Pin(mosiNo))
self.spi.init(baudrate=500_000, bits=8, polarity=0,
phase=0, firstbit=SPI.MSB)
self.CS = Pin(CSNo, Pin.OUT)
self.CS.high()
sleep_ms(1)
def read(self, chan):
write = bytearray([0x01, (0x08 | chan) << 4, 0x00])
self.CS.low()
read = bytearray(3)
self.spi.write_readinto(write, read)
self.CS.high()
data = (read[1] & 0x03) << 8 | read[2]
volts = data * 3.3 / 1023.0
return volts
adc = spiADC(0, 18, 16, 19, 17)
volts = adc.read(1)
print(volts)
Page 177
from machine import Pin,I2C
i2c0=I2C(0,scl=Pin(17),sda=Pin(16),freq=400000)
buf = bytearray([0xE7])
i2c0.writeto( 0x40, buf, True)
read= i2c0.readfrom(0x40, 1, True)
print("User Register =",read)
Page 179
from utime import sleep_ms
from machine import Pin, I2C
from time import sleep
i2c0 = I2C(0, scl=Pin(17), sda=Pin(16), freq=100*1000)
buf = bytearray([0xE3])
i2c0.writeto(0x40, buf, False)
read = i2c0.readfrom(0x40, 3, True)
msb = read[0]
lsb = read[1]
check = read[2]
print("msb lsb checksum =", msb, lsb, check)
Page 183
from utime import sleep_ms
from machine import Pin, I2C
from time import sleep
def crcCheck(msb, lsb, check):
data32 = (msb << 16) | (lsb << 8) | check
divisor = 0x988000
for i in range(16):
if data32 & 1 << (23 - i):
data32 ^= divisor
divisor >>= 1
return data32
i2c0 = I2C(0, scl=Pin(17), sda=Pin(16), freq=100*1000)
buf = bytearray([0xE3])
i2c0.writeto(0x40, buf, False)
read = i2c0.readfrom(0x40, 3, True)
msb = read[0]
lsb = read[1]
check = read[2]
print("msb lsb checksum =", msb, lsb, check)
data16 = (msb << 8) | (lsb & 0xFC)
temp = (-46.85 + (175.72 * data16 / (1 << 16)))
print("Temperature C ", temp)
print("Checksum=", crcCheck(msb, lsb, check))
buf = bytearray([0xF5])
i2c0.writeto(0x40, buf, True)
read = bytearray(3)
while True:
sleep_ms(1)
try:
i2c0.readfrom_into(0x40, read, True)
break
except:
continue
msb = read[0]
lsb = read[1]
check = read[2]
print("msb lsb checksum =", msb, lsb, check)
data16 = (msb << 8) | (lsb & 0xFC)
hum = -6 + (125.0 * data16) / 65536
print("Humidity ", hum)
print("Checksum=", crcCheck(msb, lsb, check))
Page 192
import rp2
from machine import Pin
@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, )
def blink():
label("again")
set(pins, 1)
set(pins, 0)
jmp("again")
sm = rp2.StateMachine(0, blink, freq=2000, set_base=Pin(16))
sm.active(1)
Page 195
import rp2
from machine import Pin
@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, )
def blink():
label("again")
set(pins, 1)
set(x,31)
label("loop1")
nop() [31]
jmp(x_dec,"loop1")
set(pins, 0)
set(x,31)
label("loop2")
nop() [31]
jmp(x_dec,"loop2")
jmp("again")
sm = rp2.StateMachine(0, blink, freq=2000, set_base=Pin(16))
sm.active(1)
Page 196
import rp2
from machine import Pin
@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, )
def squarewave():
pull(block)
label("again")
set(pins, 1)
mov(x, osr)
label("loop1")
jmp(x_dec, "loop1")
set(pins, 0)
mov(x, osr)
label("loop2")
jmp(x_dec, "loop2")
jmp("again")
sm = rp2.StateMachine(0, squarewave, freq=2000, set_base=Pin(16))
sm.active(1)
sm.put(0xFFF)
Page 198
import rp2
from machine import Pin
@rp2.asm_pio(out_init=(rp2.PIO.OUT_LOW, rp2.PIO.OUT_LOW))
def output():
pull(block)
label("again")
out(pins, 2)
jmp("again")
sm = rp2.StateMachine(0, output, freq=2000, out_base=Pin(
16), out_shiftdir=rp2.PIO.SHIFT_RIGHT)
sm.active(1)
sm.put(0xFEDCBA98)
Page 200
import rp2
from machine import Pin
@rp2.asm_pio(out_init=(rp2.PIO.OUT_LOW, rp2.PIO.OUT_LOW), autopull=True)
def output():
label("again")
out(pins, 2)
jmp("again")
sm = rp2.StateMachine(0, output, freq=2000, out_base=Pin(
16), out_shiftdir=rp2.PIO.SHIFT_RIGHT)
sm.active(1)
while True:
sm.put(0xFEDCBA98)
Page 202
import rp2
from machine import Pin
@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW)
def squarewave():
label("again")
nop().side(1)
jmp("again").side(0)
sm = rp2.StateMachine(0, squarewave, freq=2000,sideset_base=Pin(16))
sm.active(1)
Page 202
import rp2
from machine import Pin
@rp2.asm_pio(sideset_init=(rp2.PIO.OUT_LOW, rp2.PIO.OUT_LOW))
def squarewave():
label("again")
nop().side(2)
jmp("again").side(1)
sm = rp2.StateMachine(0, squarewave, freq=2000, sideset_base=Pin(16))
sm.active(1)
Page 204
import rp2
from machine import Pin
@rp2.asm_pio()
def light():
label("again")
in_(pins, 1)
push(block)
jmp("again")
LED = Pin(25, mode=Pin.OUT)
in1 = Pin(16, mode=Pin.IN)
sm = rp2.StateMachine(0, light, freq=2000, in_base=Pin(16))
sm.active(1)
while True:
flag = sm.get()
if (flag == 0):
LED.value(0)
else:
LED.value(1)
Page 206
import rp2
from machine import Pin
@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW)
def squarewave():
label("again")
wait(0, pin, 0)
wait(1, pin, 0)
set(pins, 1)
set(pins, 0)
jmp("again")
in1 = Pin(16, mode=Pin.IN)
sm = rp2.StateMachine(0, squarewave, freq=2000,
in_base=Pin(16), set_base=Pin(17))
sm.active(1)
Page 215
import dht
from machine import Pin
import time
dht=dht.DHT22(Pin(22))
while True:
dht.measure()
temp=dht.temperature()
print(temp)
hum=dht.humidity()
print(hum)
time.sleep(1)
Page 218
from machine import Pin
from utime import sleep_ms, ticks_us
class DHT22():
def __init__(self, gpio):
self.pin = gpio
self.pin = Pin(2, mode=Pin.OUT)
self.pin.high()
self.checksum = 0
self.temperature = 0
self.humidity = 0
sleep_ms(1)
def getReading(self):
DHT = self.pin
DHT.low()
sleep_ms(1)
DHT.init(mode=Pin.IN)
for i in range(2):
while DHT.value() == 1:
pass
while DHT.value() == 0:
pass
data = 0
t1 = ticks_us()
for i in range(32):
while DHT.value() == 1:
pass
while DHT.value() == 0:
pass
t2 = ticks_us()
data = data << 1
data = data | ((t2 - t1) > 100)
t1 = t2
checksum = 0
for i in range(8):
while DHT.value() == 1:
pass
while DHT.value() == 0:
pass
t2 = ticks_us()
checksum = checksum << 1
checksum = checksum | ((t2 - t1) > 100)
t1 = t2
byte1 = (data >> 24 & 0xFF)
byte2 = (data >> 16 & 0xFF)
byte3 = (data >> 8 & 0xFF)
byte4 = (data & 0xFF)
self.checksum = (checksum == (byte1+byte2+byte3+byte4) & 0xFF)
self.humidity = ((byte1 << 8) | byte2) / 10.0
neg = byte3 & 0x80
byte3 = byte3 & 0x7F
self.temperature = (byte3 << 8 | byte4) / 10.0
if neg > 0:
self.temperature = -self.temperature
dht = DHT22(2)
dht.getReading()
print("Checksum", dht.checksum)
print("Humidity= ", dht.humidity)
print("Temperature=", dht.temperature)
Page 222
import rp2
from machine import Pin
@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, autopush=True, in_shiftdir=rp2.PIO.SHIFT_RIGHT)
def dht22():
wrap_target()
label("again")
pull(block)
set(pins, 0)
mov(x, osr)
label("loop1")
jmp(x_dec, "loop1")
set(pindirs, 0)
wait(1, pin, 0)
wait(0, pin, 0)
wait(1, pin, 0)
wait(0, pin, 0)
set(y, 31)
label("bits")
wait(1, pin, 0)
set(x, 0)
label("loop2")
jmp(x_dec, "continue")
label("continue")
jmp(pin, "loop2")
in_(x, 4)
jmp(y_dec, "bits")
set(y, 7)
label("check")
wait(1, pin, 0)
set(x, 0)
label("loop3")
jmp(x_dec, "continue2")
label("continue2")
jmp(pin, "loop3")
in_(x, 4)
jmp(y_dec, "check")
wrap()
class DHT22():
def __init__(self, gpio):
self.sm = rp2.StateMachine(0, dht22, freq=976562, in_base=Pin(
gpio), set_base=Pin(gpio), jmp_pin=Pin(gpio))
self.sm.active(1)
def getByte(self):
count = self.sm.get()
byte = 0
for i in range(8):
byte = byte << 1
if ((count >> i * 4) & 0x0F) > 8:
byte = byte | 1
return byte
def getReading(self):
self.sm.put(1000)
byte1 = self.getByte()
print(byte1)
byte2 = self.getByte()
byte3 = self.getByte()
print(hex(byte2))
byte4 = self.getByte()
checksum = self.getByte()
self.checksum = (checksum == (byte1+byte2+byte3+byte4) & 0xFF)
self.humidity = ((byte1 << 8) | byte2) / 10.0
neg = byte3 & 0x80
byte3 = byte3 & 0x7F
self.temperature = (byte3 << 8 | byte4) / 10.0
if neg > 0:
self.temperature = -self.temperature
dht = DHT22(2)
dht.getReading()
print("Checksum", dht.checksum)
print("Humidity= ", dht.humidity)
print("Temperature=", dht.temperature)
Page 226
import rp2
from machine import Pin
@rp2.asm_pio(set_init=(rp2.PIO.OUT_LOW, rp2.PIO.OUT_LOW), autopush=True, in_shiftdir=rp2.PIO.SHIFT_LEFT)
def dht22():
wrap_target()
label("again")
pull(block)
set(pins, 0)
mov(x, osr)
label("loop1")
jmp(x_dec, "loop1")
set(pindirs, 0)
wait(1, pin, 0)
wait(0, pin, 0)
wait(1, pin, 0)
wait(0, pin, 0)
set(y, 31)
label("bits")
wait(1, pin, 0)[25]
in_(pins, 1)
wait(0, pin, 0)
jmp(y_dec, "bits")
set(y, 7)
label("check")
wait(1, pin, 0)[25]
set(pins, 2)
set(pins, 0)
in_(pins, 1)
wait(0, pin, 0)
jmp(y_dec, "check")
push(block)
wrap()
class DHT22():
def __init__(self, gpio):
self.sm = rp2.StateMachine(0, dht22, freq=490196, in_base=Pin(
gpio), set_base=Pin(gpio), jmp_pin=Pin(gpio))
self.sm.active(1)
def getReading(self):
self.sm.put(500)
data = 0
data = self.sm.get()
byte1 = (data >> 24 & 0xFF)
byte2 = (data >> 16 & 0xFF)
byte3 = (data >> 8 & 0xFF)
byte4 = (data & 0xFF)
checksum = self.sm.get() & 0xFF
self.checksum = (checksum == (byte1+byte2+byte3+byte4) & 0xFF)
self.humidity = ((byte1 << 8) | byte2) / 10.0
neg = byte3 & 0x80
byte3 = byte3 & 0x7F
self.temperature = (byte3 << 8 | byte4) / 10.0
if neg > 0:
self.temperature = -self.temperature
dht = DHT22(2)
dht.getReading()
print("Checksum", dht.checksum)
print("Humidity= ", dht.humidity)
print("Temperature=", dht.temperature)
Page 248
from utime import sleep_ms, sleep_us
from machine import Pin
from time import sleep
class DS18B20:
def __init__(self, pin):
self.pin = Pin(pin, mode=Pin.IN)
self.pin.high()
def presence(self):
self.pin.init(mode=Pin.OUT)
self.pin.high()
sleep_ms(1)
self.pin.low()
sleep_us(480)
self.pin.init(mode=Pin.IN)
sleep_us(70)
b = self.pin.value()
sleep_us(410)
return b
@micropython.native
def writeBit(self, b):
if b == 1:
delay1 = 1
delay2 = 30
else:
delay1 = 30
delay2 = 0
self.pin.low()
for i in range(delay1):
pass
self.pin.high()
for i in range(delay2):
pass
def writeByte(self, byte):
self.pin.init(mode=Pin.OUT)
for i in range(8):
self.writeBit(byte & 1)
byte = byte >> 1
self.pin.init(mode=Pin.IN)
@micropython.native
def readBit(self):
self.pin.init(mode=Pin.OUT)
self.pin.low()
self.pin.high()
self.pin.init(mode=Pin.IN)
b = self.pin.value()
sleep_us(60)
return b
def readByte(self):
byte = 0
for i in range(8):
byte = byte | self.readBit() << i
return byte
def convert(self):
self.writeByte(0x44)
for i in range(500):
sleep_ms(10)
if self.readBit() == 1:
j = i
break
return j
def crc8(self, data, len):
crc = 0
for i in range(len):
databyte = data[i]
for j in range(8):
temp = (crc ^ databyte) & 0x01
crc >>= 1
if temp:
crc ^= 0x8C
databyte >>= 1
return crc
def getTemp(self):
if self.presence() == 1:
return -1000
self.writeByte(0xCC)
if self.convert() == 500:
return -3000
self.presence()
self.writeByte(0xCC)
self.writeByte(0xBE)
data = []
for i in range(9):
data.append(self.readByte())
if self.crc8(data, 9) != 0:
return -2000
t1 = data[0]
t2 = data[1]
temp1 = (t2 << 8 | t1)
if t2 & 0x80:
temp1 = temp1 | 0xFFFF0000
return temp1/16
dS18B20 = DS18B20(2)
if dS18B20.presence() == 1:
print("No device")
else:
print("Device present")
print(dS18B20.getTemp())
Page 250
from utime import sleep_ms
from machine import Pin
import onewire
class DS18B20:
def __init__(self,pin):
self.ow=onewire.OneWire(Pin(pin))
def convert(self):
self.ow.writebyte(0x44)
for i in range(500):
sleep_ms(10)
if self.ow.readbit() == 1:
j=i
break
return j
def getTemp(self):
if not self.ow.reset:
return -1000
self.ow.writebyte(0xCC)
if self.convert()==500:
return -3000
self.ow.reset()
self.ow.writebyte( 0xCC)
self.ow.writebyte( 0xBE)
data=bytearray(9)
self.ow.readinto(data)
if self.ow.crc8(data)!=0:
return -2000
t1 = data[0]
t2 = data[1]
temp1 = (t2 << 8 | t1)
if t2 & 0x80:
temp1=temp1 | 0xFFFF0000
return temp1/16
dS18B20=DS18B20(22)
print(dS18B20.getTemp())
Page 257
import rp2
from machine import Pin
from utime import sleep_ms
@rp2.asm_pio(set_init=rp2.PIO.OUT_HIGH, out_init=rp2.PIO.OUT_HIGH, autopush=True, push_thresh=8)
def DS1820():
wrap_target()
label("again")
pull(block)
mov(x, osr)
jmp(not_x, "read")
label("write")
set(pindirs, 1)
set(pins, 0)
label("loop1")
jmp(x_dec, "loop1")
set(pindirs, 2)[31]
wait(1, pin, 0)[31]
pull(block)
mov(x, osr)
label("bytes1")
pull(block)
set(y, 7)
set(pindirs, 3)
label("bit1")
set(pins, 0)[1]
out(pins, 1)[31]
set(pins, 1)[20]
jmp(y_dec, "bit1")
jmp(x_dec, "bytes1")
set(pindirs, 0)[31]
jmp("again")
label("read")
pull(block)
mov(x, osr)
label("bytes2")
set(y, 7)
label("bit2")
set(pindirs, 1)
set(pins, 0)[1]
set(pindirs, 0)[5]
in_(pins, 1)[10]
jmp(y_dec, "bit2")
jmp(x_dec, "bytes2")
wrap()
class DS18B20:
def __init__(self, pin):
self.sm = rp2.StateMachine(0, DS1820, freq=490196, set_base=Pin(2), out_base=Pin(
2), in_base=Pin(2), out_shiftdir=rp2.PIO.SHIFT_RIGHT, in_shiftdir=rp2.PIO.SHIFT_RIGHT)
self.sm.active(1)
def writeBytes(self, bytes, len):
self.sm.put(250)
self.sm.put(len-1)
for i in range(len):
self.sm.put(bytes[i])
def readBytes(self, len):
self.sm.put(0)
self.sm.put(len-1)
bytes = []
for i in range(len):
bytes.append(self.sm.get() >> 24)
return bytes
def getTemp(self):
self.writeBytes([0xCC, 0x44], 2)
sleep_ms(1000)
self.writeBytes([0xCC, 0xBE], 2)
data = self.readBytes(9)
t1 = data[0]
t2 = data[1]
temp1 = (t2 << 8 | t1)
if t2 & 0x80:
temp1 = temp1 | 0xFFFF0000
return temp1/16
dS18B20 = DS18B20(2)
print(dS18B20.getTemp())
Page 267
from machine import UART, Pin
from utime import sleep_ms
uart = UART(1, baudrate=9600, bits=8, parity=2, rx=Pin(5), tx=Pin(4))
SendData = bytearray("Hello World \n", "utf-8")
uart.write(SendData)
RecData = uart.read()
print(RecData)
Page 268
from machine import UART, Pin
from utime import sleep_ms
uart = UART(1, baudrate=9600, bits=8, parity=2, rx=Pin(5), tx=Pin(4))
SendData = bytearray("A"*32, "utf-8")
uart.write(SendData)
sleep_ms(500)
RecData = uart.read(32)
print(RecData)
Page 266
from machine import UART, Pin, mem32
from utime import sleep_ms
def uart_read(uart):
rxData = bytes()
while uart.any() > 0:
rxData += uart.read(1)
return rxData
uart = UART(1, baudrate=9600, bits=8, parity=2, rx=Pin(5), tx=Pin(4))
SendData = bytearray("A"*65, "utf-8")
uart.write(SendData)
sleep_ms(500)
RecData = uart_read(uart)
print(RecData)
print(len(RecData))
Page 278
def setup(country, ssid, key):
rp2.country(country)
wifi=network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED=Pin("LED", Pin.OUT)
LED.high()
timeout=20000
wifi.connect(ssid,key)
timer=Timer()
timer.init(period=200, mode=Timer.PERIODIC,
callback=lambda t:LED.toggle())
s=0
while timeout>0:
s=wifi.status()
if s==3 or s<0:
break
sleep_ms(100)
timeout=timeout-100
if(s<2):
timer.init(period=1000, mode=Timer.PERIODIC,
callback=lambda t:LED.toggle())
else:
timer.deinit()
LED.high()
return wifi
Page 280
wifi=network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
aps=wifi.scan()
for ap in aps:
print(ap)
Page 282
from http.server import HTTPServer, BaseHTTPRequestHandler
from io import BytesIO
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def sendResponse(self, cmd):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length)
self.send_response(200)
self.end_headers()
response = BytesIO()
response.write(b'This is a '+bytes(cmd, 'utf-8')+
b' request. ')
response.write(b'Received: ')
response.write(body)
self.wfile.write(response.getvalue())
def do_GET(self):
self.send_response(200)
self.end_headers()
self.wfile.write(b'Hello, world!')
def do_HEAD(self):
self.send_response(200)
self.end_headers()
def do_POST(self):
self.sendResponse("POST")
def do_PUT(self):
self.sendResponse("PUT")
def do_DELETE(self):
self.sendResponse("DELETE")
def do_PATCH(self):
self.sendResponse("PATCH")
httpd = HTTPServer(('', 8080), SimpleHTTPRequestHandler)
httpd.serve_forever()
Page 285
import urequests
import network
import rp2
from machine import Pin, Timer
from time import sleep_ms
def setup(country, ssid, key):
rp2.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin("LED", Pin.OUT)
LED.high()
timeout = 20000
wifi.connect(ssid, key)
timer = Timer()
timer.init(period=200, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
s = 0
while timeout > 0:
s = wifi.status()
if s == 3 or s < 0:
break
sleep_ms(100)
timeout = timeout-100
if(s < 2):
timer.init(period=1000, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
else:
timer.deinit()
LED.high()
return wifi
wifi = setup("country", "ssid", "key")
url = "http://192.168.253.45:8080"
r = urequests.get(url)
print(r.content)
r.close()
buf = b'Hello World'
r = urequests.post(url, data=buf)
print(r.content)
r.close()
r = urequests.put(url, data=buf)
print(r.content)
r.close()
r = urequests.patch(url, data=buf)
print(r.content)
r.close()
r = urequests.head(url)
print(r.content)
print(r.headers)
r.close()
r = urequests.delete(url, data=buf)
print(r.content)
r.close()
Page 287
from machine import Pin, Timer
import network
import rp2
import onewire
import ds18x20
from time import sleep_ms
import urequests
def setup(country, ssid, key):
rp2.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin("LED", Pin.OUT)
LED.high()
timeout = 20000
wifi.connect(ssid, key)
timer = Timer()
timer.init(period=200, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
s = 0
while timeout > 0:
s = wifi.status()
if s == 3 or s < 0:
break
sleep_ms(100)
timeout = timeout-100
if(s < 2):
timer.init(period=1000, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
else:
timer.deinit()
LED.high()
return wifi
wifi = setup("country", "ssid", "key")
url = "http://192.168.253.45:8080"
ow = onewire.OneWire(Pin(22))
presence = ow.reset()
if presence:
print("Device present")
else:
print("No device")
DS = ds18x20.DS18X20(ow)
roms = DS.scan()
while True:
DS.convert_temp()
temp = DS.read_temp(roms[0])
buf = str(temp).encode("utf-8")
try:
r = urequests.put(url, data=buf)
r.close()
except:
print("Server Not Online")
sleep_ms(500)
Page 288
from http.server import HTTPServer, BaseHTTPRequestHandler
from io import BytesIO
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def log_message(self,*args, **kwargs):
pass
def do_PUT(self):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length)
bodyString= body.decode(encoding="utf-8")
temp=float(bodyString)
print(temp)
self.send_response(200)
self.end_headers()
httpd = HTTPServer(('', 8080), SimpleHTTPRequestHandler)
httpd.serve_forever()
Page 294
import network
import socket
import rp2
from machine import Pin, Timer
from time import sleep_ms
from time import sleep_ms
def setup(country, ssid, key):
rp2.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin("LED", Pin.OUT)
LED.high()
timeout = 20000
wifi.connect(ssid, key)
timer = Timer()
timer.init(period=200, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
s = 0
while timeout > 0:
s = wifi.status()
if s == 3 or s < 0:
break
sleep_ms(100)
timeout = timeout-100
if(s < 2):
timer.init(period=1000, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
else:
timer.deinit()
LED.high()
return wifi
wifi = setup("country", "ssid", "key")
ai = socket.getaddrinfo("www.example.com", 80,socket.AF_INET)
addr = ai[0][-1]
s = socket.socket(socket.AF_INET)
s.connect(addr)
request = b"GET /index.html HTTP/1.1\r\nHost:example.org\r\n\r\n"
s.send(request)
print(s.recv(512))
Page 296
import network
import socket
import rp2
from machine import Pin, Timer
import ssl
from time import sleep_ms
def setup(country, ssid, key):
rp2.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin("LED", Pin.OUT)
LED.high()
timeout = 20000
wifi.connect(ssid, key)
timer = Timer()
timer.init(period=200, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
s = 0
while timeout > 0:
s = wifi.status()
if s == 3 or s < 0:
break
sleep_ms(100)
timeout = timeout-100
if(s < 2):
timer.init(period=1000, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
else:
timer.deinit()
LED.high()
return wifi
wifi = setup("country", "ssid", "key")
ai = socket.getaddrinfo("example.com", 443,socket.AF_INET)
addr = ai[0][-1]
s = socket.socket(socket.AF_INET)
s.connect(addr)
sslSock=ssl.wrap_socket(s)
request = b"GET / HTTP/1.1\r\nHost:example.com\r\n\r\n"
sslSock.write(request)
print(sslSock.read(1024))
Page 299-300
import network
import socket
import rp2
from time import sleep_ms
from machine import Pin, Timer
import onewire
import ds18x20
def setup(country, ssid, key):
rp2.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin("LED", Pin.OUT)
LED.high()
timeout = 20000
wifi.connect(ssid, key)
timer = Timer()
timer.init(period=200, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
s = 0
while timeout > 0:
s = wifi.status()
if s == 3 or s < 0:
break
sleep_ms(100)
timeout = timeout-100
if(s < 2):
timer.init(period=1000, mode=Timer.PERIODIC,
callback=lambda t: LED.toggle())
else:
timer.deinit()
LED.high()
return wifi
wifi = setup("country", "ssid", "key")
print("connected")
print(wifi.ifconfig())
ow = onewire.OneWire(Pin(22))
presence = ow.reset()
if presence:
print("Device present")
else:
print("No device")
DS = ds18x20.DS18X20(ow)
roms = DS.scan()
template = """<!DOCTYPE html>
<html>
<head> <title>Temperature</title> </head>
<body> <h1>Current Temperature</h1>
Hello Pico W Server World <br/>
The Temperature is: <!--#temp--><br/>
</body>
</html>
"""
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(addr)
s.listen(0)
while True:
cl, addr = s.accept()
print('client connected from', addr)
print(cl.recv(512))
DS.convert_temp()
temp = DS.read_temp(roms[0])
html=template.replace("<!--#temp-->",str(temp))
headers = ("HTTP/1.1 200 OK\r\n"
"Content-Type: text/html; charset=UTF-8\r\n"
"Server:Pico\r\n"
f"Content-Length:{len(html)}\r\n\r\n"
)
buf = headers.encode("utf-8")+html.encode("utf-8")
cl.send(buf)
cl.close()
s.close()
Page 303
import network
import socket
import rp2
from time import sleep_ms
from machine import Pin, Timer
import onewire
import ds18x20
import ssl
def setup(country, ssid, key):
rp2.country(country)
wifi=network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED=Pin("LED", Pin.OUT)
LED.high()
timeout=20000
wifi.connect(ssid,key)
timer=Timer()
timer.init(period=200, mode=Timer.PERIODIC,
callback=lambda t:LED.toggle())
s=0
while timeout>0:
s=wifi.status()
if s==3 or s<0:
break
sleep_ms(100)
timeout=timeout-100
if(s<2):
timer.init(period=1000, mode=Timer.PERIODIC,
callback=lambda t:LED.toggle())
else:
timer.deinit()
LED.high()
return wifi
key=b'0\x82\x04\xbf\x02\x01\x000\r\x06\t*\x86H\x86\xf7\r\x01\x01\x01\x05\x00\x04\x82\x04\xa90\x82\x04\xa5\x02\x01\x00\x02\x82\x01\x01\x00\xb9SU\x05\x056\x8c\x92I\\?\xe5rb\x14\xaceG\xb8\x04n\x8f\xb6O\x04o\x9a\xcdP\xbe\xc3\xfb\x07\x8fl\xe4E\xd6\xf6>\xeb\\\xff\x9f\xbe\xad\x941\xda=\x9f\xca\x19\xa8iL\xa8\x91\xd8\xad\xafm\xb7\\|\xd8\x82\xa05:Oe\xe6\xe5\x18\xa6\x0f.\xea\x10<\xe6qh\x00?K\x12m)\xea\x08)\x9e>\'\xab\xca_\xddH\xa3\xd08\xe5\xec0+RB\xae\x8bR\'S\x8dq\x86\xc9\xa9{\xbd1W\xcbG\xb8\xe7V\xbc\x12\x077\x93\xab\xa1\xd6\xb1o\xc1\xdf\x0b\x0b\xa1\xf4Vm\x18\x8b\xf3\xf2\x9c\x86\xa1o\x92|Y\t\x85\x08UpnIFi3\x1d\xd4\x12\x863\n\xef\xb0\xa3\xbf\xd4\xf6\x1c7\x993\xe4\xf4$\x17\xe8\xb7\xb8k\xaaV\xeeB\x92\xa6*\xd9\xa9Y\x88P\x00I\x93Z4)\xb5\xfaW\xe6b\x04L\xee\xe9\xa4\xb1\xbf\'@s\xd0\xb3}\xc3\xf1[\t\xd9\x91\xeau\x0b\xd2\xba\x94\x7f\xbdO\x11\\e\x81Ed\x88\x97Z\x1a~\x16!\x02\x03\x01\x00\x01\x02\x82\x01\x01\x00\x81\xd9\x88\x85\x86\xfc\x8c\x8b\xe7\x08\xd2\xe0R?\xb4\x9a\x8209\x18)\xdbY\xf2\x8dz!-\xe0xyZ\xc7\x16PF\xb5D\x83\xae\xdc<\x82\x03\x0c\x98\x14p\xc5\xa8M\xf0M\xff\xf9\x1f\xb40\xd4p\x05\xad\xcb>\xeb^\xccO\xb2[\xd3\xcb\xe3v\xfb\xc9Ft)\x9e\x0c\xfd\xad\xd2\x1f\xf29\x08\x85"L\x0fB\x11\xd5\x1c\xf8\xbaHg\x04\x81z\xe0\x93\x00\xe5SED\xe1\x85N\x9f\xadd:z%\x8c1\xde\x02\xd7\xaf\xdf\xe6\x06F\xf6\xdc\x03\xf2K\x19B \x8eX\x9dx\xbb\x9c\xbcE\xa8:\x0f\xab\x0b\xd7\x8f\x7fV\xb1\x0c\xe4\x83\xfc\xcd\x9c\x1c\x072\x0e#\xc2\xb22o94r\xf6kp+\xd9\xcc/\x80\x11\xaa\xeb\xea\xac\'\xba\xecm\xe3;\xbf\xee{\xf7\x07K#\xe7\xc5\xadQ3\x9a[^\xf8\xe5\xb4}\xdc4\xedrD\x01\xef\x8ek\x100B\x03t6^\x87\\\x9c\xf9\x98\tN\xb9\xd9\x9a\xf1\xd3,o\xf5\xf3>\x9f8\xb7\x1f\x1a%\r\x8d\x9a\xd4S\x01\x02\x81\x81\x00\xee\xa5h5)w\xba,\x83\xad!\xa5\x7fzg\xa8v\x97F\xe0\x9a\x18\xe3\xc01\xb4\xd2\x96\x1a;\x94>\x99\xd9\xad\xcd<\xee\xf1\x9e\x041\x06\x9a\x8f\x82\xa4&z\xe0;[8{\xecu"\xa3\xeav&\x1e\xf6\xc2<F^\x19\x91\xa7\x05\x80=u\xe4\xf6c\xeb\x99\xcb\xb6\\\xcb\x88\x96]\x07\xf2\xef\xa8\x80\x0e\x9dh`\x19\xa5+\x03\xd3<\x06\xf4\x81\x96\x18\xe0>i\xbe:\xcc\xb9\x0cY\xfa\x03\x18\x11\'\x10\xa66\xb7-\xfdOq\x02\x81\x81\x00\xc6\xcdQ}\xa2\xdf\x84\x95\n\xac+\x1fx\x98\xb02\x19\x10yP\xa4<\xba\xb1F\xbc\x18\xdc \xe7\x91k\x8ed1a\xdb\xe1\x01\x0e\xb3\xba\x7fF{\xa9\x15\xcfN!\xaeBE\xe2\xdfv\xab\xa7\xf2/\xf7\x9cZ\xb1f\xbc\xe0z\x11\xab\xaf\xc0\x01 v_\x01\x1b\xac\xb8Q.h\xaa1yXF\x95\x1fb\x9e\x9c\x87\x9a[\x98\x90\x96\x0c\xe3\xf5#\nu8\\\xf0\x82\xf0\xec\x97\xa9\xb0\x10q\xd8\x84o\x0b#\r<\x05\x81J9\xb1\x02\x81\x80jA\x83\x90\x88\x12"\xf6\xc6\xfaCL\xe8\xe1\x9b]\xca\xcf\xb8c0\xb9|N\x8a\xd34 Y5\xc5\xdf\xc9\xa8\xbeU\xef\x97\x84E\x13 \xb1\x0c\x08q\xe6\x9c\xab\x81ClnM\xdf\x0e\x98\x89\xdbO\x17\xd2\x19\x94\x8a9\xda\x94\x0f\xe2\t\xf4\xfbh\x8e\xb5\x95\xef\xc4\xde\x8b\'\xee\x07\xb6\xcb]J\xb1\xa2\x98\xc1\xe9\x1c\x1c\r\xcf\x18\xc3\xef=~\xebF\xf7\x89\xc3\xee\x86.\x89\x07\xb6,\xe5\xb3\x07\xc5\xa3}}PDts)\xa2A\x02\x81\x81\x00\xac#^[\x86+:\x96\xff-\xc3\r6\x14(\x04\xc9\x15-\xa6x\xff\xa8\xbc\x15\xbe\x8b\\\x18\x15\xcb"1\xa2i\xec\rC\x0f\xf2V\x07\xb7k%jl[\x1b\x91(]t<\x158\xa1<\x04\x06*\xc64\xf5\x85;(\xb8*\x12\xdaTK\xe5z\xf9\x9aq\x07&v\x0c\xd4N\x02\x16\xcb,\x1a\xb5\x99d3\xafk%\xc2\xbd\xf7_d\x07\x7f\xf6\xef7\x05\xaa\xb0\x06\xc3&3\xa5#( \xcd\xd3\x84\xf6-\xe0y\xf7\xd0x\x91\x02\x81\x81\x00\x9fn\xb6|\xbf\x8bu\x98\xf0\xc3\xc2k\x1cn\x18y3\x88\xc8\x07l+\xc5\xbf\xd0\x1f\xa8\xe2e\xc6=\xb8\x1a\xfdW\x929;\xfc5~\x96\xb3\x9e\xa5A\xe3\x94\x8d\xc1I\x91\x87\xe0\xcd\x9bO\x80Z\xdcf\x157\xd0\x96:\x16\xb4%\xce\xd9\x17\xfa\xbeF\x19\x81\xc9\x96\xc2\xfd\x84\xafF\x87"\x91\xfb<\xd0\xc8\x11\xadJb\xf1\x17q\xeb\xb0\x11\xc3W\xc7\xf5\xe1\xa1B\x89\x8bZ\xc6\xe7\xa2\xf4?w\xa4\x0c\n\x89\xfd\x00S4\xabp\xd1'
cert=b'0\x82\x03k0\x82\x02S\xa0\x03\x02\x01\x02\x02\x14b\x01\xd9E\xad\x0e\xb3\x7f\x14\xc1\x83\x029V4|\x82E2U0\r\x06\t*\x86H\x86\xf7\r\x01\x01\x0b\x05\x000E1\x0b0\t\x06\x03U\x04\x06\x13\x02AU1\x130\x11\x06\x03U\x04\x08\x0c\nSome-State1!0\x1f\x06\x03U\x04\n\x0c\x18Internet Widgits Pty Ltd0\x1e\x17\r221219141736Z\x17\r231219141736Z0E1\x0b0\t\x06\x03U\x04\x06\x13\x02AU1\x130\x11\x06\x03U\x04\x08\x0c\nSome-State1!0\x1f\x06\x03U\x04\n\x0c\x18Internet Widgits Pty Ltd0\x82\x01"0\r\x06\t*\x86H\x86\xf7\r\x01\x01\x01\x05\x00\x03\x82\x01\x0f\x000\x82\x01\n\x02\x82\x01\x01\x00\xb9SU\x05\x056\x8c\x92I\\?\xe5rb\x14\xaceG\xb8\x04n\x8f\xb6O\x04o\x9a\xcdP\xbe\xc3\xfb\x07\x8fl\xe4E\xd6\xf6>\xeb\\\xff\x9f\xbe\xad\x941\xda=\x9f\xca\x19\xa8iL\xa8\x91\xd8\xad\xafm\xb7\\|\xd8\x82\xa05:Oe\xe6\xe5\x18\xa6\x0f.\xea\x10<\xe6qh\x00?K\x12m)\xea\x08)\x9e>\'\xab\xca_\xddH\xa3\xd08\xe5\xec0+RB\xae\x8bR\'S\x8dq\x86\xc9\xa9{\xbd1W\xcbG\xb8\xe7V\xbc\x12\x077\x93\xab\xa1\xd6\xb1o\xc1\xdf\x0b\x0b\xa1\xf4Vm\x18\x8b\xf3\xf2\x9c\x86\xa1o\x92|Y\t\x85\x08UpnIFi3\x1d\xd4\x12\x863\n\xef\xb0\xa3\xbf\xd4\xf6\x1c7\x993\xe4\xf4$\x17\xe8\xb7\xb8k\xaaV\xeeB\x92\xa6*\xd9\xa9Y\x88P\x00I\x93Z4)\xb5\xfaW\xe6b\x04L\xee\xe9\xa4\xb1\xbf\'@s\xd0\xb3}\xc3\xf1[\t\xd9\x91\xeau\x0b\xd2\xba\x94\x7f\xbdO\x11\\e\x81Ed\x88\x97Z\x1a~\x16!\x02\x03\x01\x00\x01\xa3S0Q0\x1d\x06\x03U\x1d\x0e\x04\x16\x04\x14\xcf\x1e\x1ce\xccs,\xd7b^\xd3\x99n\xa4\xebi\xe7\xe3\xe9S0\x1f\x06\x03U\x1d#\x04\x180\x16\x80\x14\xcf\x1e\x1ce\xccs,\xd7b^\xd3\x99n\xa4\xebi\xe7\xe3\xe9S0\x0f\x06\x03U\x1d\x13\x01\x01\xff\x04\x050\x03\x01\x01\xff0\r\x06\t*\x86H\x86\xf7\r\x01\x01\x0b\x05\x00\x03\x82\x01\x01\x00\x1c\x1d\x88\xca\xbd/5\xdf\x1b\xdb\xfe\xe4\x92\x7f\x98AK\xe37\x18qE\xf9\xc7D\x9ex\xb2Fo\xc3w\x17V\xe5fD1\x88\x7f\xe5\xfe\xd5}x\x10i\x9ah\xccl-*/\xfaa\x99\xc0\x82\xec\xbe\xca\'\x91v<\x1e g\xc3mm\xfe\x0f\xf7\xc5\xa8\xc8\xe0E\xce\xbb\\\x87s\x1d\x92b\xdd\x11\x12\x99\x196\x81\xf1\x15F\xf7i\xa7\xa2\x9b\xe6yG\x0e\xd73\x82\x13\x14\x95\xa4f-X\xcf\xb2\xcd\xb9AY=\xce\xb4 X\xe7o\xf5\x83\xad\xb5{y\xb4\x84\xd1\xa8\x0f\xcc;\x19\xd2\xd8A:\x1f\xd3\xc20\xb5\x12\'\xa0\xf0y\x8fE\x97\x0b\xbaj\x1c\xc6+\xfd\t$,\x05 B\x98C\x14j\xa2v6/q\xe8\x1bC\xd2w\xd7Z\xbeG\xd23",`\x00P\xb8a/\xea\xc5/\xc6Gh\xbe\x1e5\n`\x97g\t\xe6\xee\xfd\x88x\xfb\xeb\xe5\xb1\xd3\x96\x896*LE\xb7q\xe9\xf6\x07v\xac~\'s=\xe5\xa1N\x00f\x85!\x0e\xddt*\x98\x8a'
wifi = setup("country", "ssid", "key")
print(wifi.ifconfig())
ow = onewire.OneWire(Pin(22))
presence = ow.reset()
if presence:
print("Device present")
else:
print("No device")
DS = ds18x20.DS18X20(ow)
roms = DS.scan()
template = """<!DOCTYPE html>
<html>
<head> <title>Temperature</title> </head>
<body> <h1>Current Temperature</h1>
Hello Pico W Server World <br/>
The Temperature is: <!--#temp--><br/>
</body>
</html>
"""
addr = socket.getaddrinfo('0.0.0.0', 443)[0][-1]
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(addr)
s.listen(5)
while True:
cl, addr = s.accept()
print('client connected from', addr)
client_s =None
try:
client_s = ssl.wrap_socket(cl, server_side=True, key=key, cert=cert)
print("wrapped",client_s)
while True:
h = client_s.readline()
if h == b"" or h == b"\r\n":
break
print(h.decode(), end="")
DS.convert_temp()
temp = DS.read_temp(roms[0])
html=template.replace("<!--#temp-->",str(temp))
headers = ("HTTP/1.1 200 OK\r\n"
"Content-Type: text/html; charset=UTF-8\r\n"
"Server:Pico\r\n"
f"Content-Length:{len(html)}\r\n\r\n"
)
buf = headers.encode("utf-8")+html.encode("utf-8")
client_s.write(buf)
client_s.close()
except Exception as e:
print("exception ",e)
s.close()
Page 315
import uasyncio
async def count(n):
for i in range(n):
print(i)
return n
async def main(myValue):
t1 = uasyncio.create_task(count(10))
print("Hello Coroutine World")
await uasyncio.sleep(5)
result = await t1
print("The result of the task =",result)
return myValue
result= uasyncio.run(main(42))
print(result)
Page 317
import uasyncio
async def test1(msg):
print(msg)
return msg
async def main():
result = await uasyncio.gather(test1("one"),test1("two"))
print(result)
print("Hello Coroutine World")
uasyncio.run(main())
Page 319
import uasyncio
async def test1(msg):
try:
await uasyncio.sleep(0)
except:
pass
print(msg)
return msg
async def main():
t1 = uasyncio.create_task(test1("one"))
await uasyncio.sleep(0)
t1.cancel()
print("Hello Coroutine World")
await uasyncio.sleep(0)
uasyncio.run(main())
Page 319
import uasyncio
async def test(msg):
print(msg)
raise Exception("Test exception")
async def main():
t1=uasyncio.create_task(test("one"))
try:
await t1
except:
print("an exception has occurred")
print("Hello Coroutine World")
await uasyncio.sleep(0)
uasyncio.run(main())
Page 320
import uasyncio
async def test(msg):
print(msg)
raise Exception("Test exception")
async def main():
t1=uasyncio.create_task(test("one"))
result=None
try:
result=await uasyncio.gather(t1,return_exceptions=True)
except:
print("an exception has occurred")
print("Hello Coroutine World")
print(result)
await uasyncio.sleep(0)
uasyncio.run(main())
Page 322
import uasyncio
async def count():
global myCounter
for i in range(1000):
temp = myCounter+1
await uasyncio.sleep(0)
myCounter = temp
async def main():
await uasyncio.gather(count(),count())
print(myCounter)
myCounter=0
uasyncio.run(main())
Page 323
import uasyncio
async def count():
global myCounter
global myLock
for i in range(1000):
async with myLock:
temp=myCounter+1
await uasyncio.sleep(0)
myCounter=temp
async def main():
await uasyncio.gather(count(),count())
print(myCounter)
myCounter=0
myLock=uasyncio.Lock()
uasyncio.run(main())
Page 324
import uasyncio
from machine import Pin
async def blink(led, period_ms):
while True:
led.on()
await uasyncio.sleep_ms(5)
led.off()
await uasyncio.sleep_ms(period_ms)
async def main(led1, led2):
uasyncio.create_task(blink(led1, 700))
uasyncio.create_task(blink(led2, 400))
await uasyncio.sleep_ms(10_000)
uasyncio.run(main(Pin(0,Pin.OUT), Pin(1,Pin.OUT)))
Page 325
import uasyncio
from machine import Pin
from time import sleep_ms
async def blink(led, period_ms):
while True:
led.on()
await uasyncio.sleep_ms(5)
led.off()
await uasyncio.sleep_ms(period_ms)
async def timewaste():
while True:
sleep_ms(10)
await uasyncio.sleep_ms(0)
async def main(led1, led2):
uasyncio.create_task(blink(led1, 700))
uasyncio.create_task(blink(led2, 400))
uasyncio.create_task(timewaste())
await uasyncio.sleep_ms(10_000)
Page 327
import uasyncio
from time import sleep_ms
from machine import Pin, Timer
import rp2
import network
def setup(country, ssid, key):
rp2.country(country)
wifi=network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED=Pin("LED", Pin.OUT)
LED.high()
timeout=20000
wifi.connect(ssid,key)
timer=Timer()
timer.init(period=200, mode=Timer.PERIODIC,
callback=lambda t:LED.toggle())
s=0
while timeout>0:
s=wifi.status()
if s==3 or s<0:
break
sleep_ms(100)
timeout=timeout-100
if(s<2):
timer.init(period=1000, mode=Timer.PERIODIC,
callback=lambda t:LED.toggle())
else:
timer.deinit()
LED.high()
return wifi
async def main():
reader,writer= await uasyncio.open_connection("www.example.com",80)
request = b"GET /index.html HTTP/1.1\r\nHost:example.org\r\n\r\n"
writer.write(request)
await writer.drain()
print(await reader.read(512))
reader.close()
wifi = setup(country, ssid, key)
uasyncio.run(main())
Page 330
import uasyncio
import network
import rp2
from machine import Pin, Timer
from time import sleep_ms
import onewire
import ds18x20
def setup(country, ssid, key):
rp2.country(country)
wifi=network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED=Pin("LED", Pin.OUT)
LED.high()
timeout=20000
wifi.connect(ssid,key)
timer=Timer()
timer.init(period=200, mode=Timer.PERIODIC, callback=lambda t:LED.toggle())
s=0
while timeout>0:
s=wifi.status()
if s==3 or s<0:
break
sleep_ms(100)
timeout=timeout-100
if(s<2):
timer.init(period=1000, mode=Timer.PERIODIC,callback=lambda t:LED.toggle())
else:
timer.deinit()
LED.high()
return wifi
wifi = setup("country", "ssid", "key")
ow = onewire.OneWire(Pin(22))
presence = ow.reset()
if presence:
print("Device present")
else:
print("No device")
DS = ds18x20.DS18X20(ow)
roms = DS.scan()
template = """<!DOCTYPE html>
<html>
<head> <title>Temperature</title> </head>
<body> <h1>Current Temperature</h1>
Hello Pico W Server World <br/>
The Temperature is: <!--#temp--><br/>
</body>
</html>
"""
async def serve_client(reader,writer):
print("client")
print(await reader.read(512))
DS.convert_temp()
temp = DS.read_temp(roms[0])
html=template.replace("<!--#temp-->",str(temp))
headers = ("HTTP/1.1 200 OK\r\n"
"Content-Type: text/html; charset=UTF-8\r\n"
"Server:Pico\r\n"
f"Content-Length:{len(html)}\r\n\r\n"
)
buf = headers.encode("utf-8")+html.encode("utf-8")
writer.write(buf)
await writer.drain()
writer.close()
await writer.wait_closed()
async def main():
await uasyncio.start_server(serve_client, '192.168.253.58', 80,backlog=5)
while True:
print("heartbeat")
await uasyncio.sleep(1)
uasyncio.run(main())
Page 336
from machine import mem32, Pin
from time import sleep_ms
led = Pin(25, mode=Pin.OUT)
addrSIO = 0xd0000000
while True:
mem32[addrSIO + 0x014] = 1 << 25
sleep_ms(500)
mem32[addrSIO + 0x018] = 1 << 25
sleep_ms(500)
Page 338
from machine import Pin
import machine
def gpio_get():
return machine.mem32[0xd0000000+0x010]
def gpio_set(value, mask):
machine.mem32[0xd0000000+0x01C] =
(machine.mem32[0xd0000000+0x010]) ^ value & mask
pin = Pin(22, Pin.OUT)
pin = Pin(21, Pin.OUT)
value1 = 1 << 22 | 0 << 21
value2 = 0 << 22 | 1 << 21
mask = 1 << 22 | 1 << 21
while True:
gpio_set(value1, mask)
gpio_set(value2, mask)
Page 344
import _thread
counter=0
def task():
global counter
print("thread started")
for i in range(1000):
counter=counter+1
_thread.start_new_thread(task,())
for i in range(1000):
counter=counter+1
time.sleep(0.5)
print(counter)
Page 345
import time, _thread, machine
counter=0
myLock=_thread.allocate_lock()
def task():
global counter, myLock
print("thread started")
print(myLock.locked())
for i in range(1000):
myLock.acquire()
time.sleep_us(1)
counter=counter+1
myLock.release()
time.sleep_us(1)
_thread.start_new_thread(task,())
for i in range(1000):
myLock.acquire()
time.sleep_us(1)
counter=counter+1
myLock.release()
time.sleep_us(1)
time.sleep(0.5)
print(counter)
Program Listings
Master the Raspberry Pi Pico in C:
WiFi with lwIP & mbedtls
We have decided not to make the programs available as a download because this is not the point of the book - the programs are not finished production code but something you should type in and study.
The best solution is to provide the source code of the programs in a form that can be copied and pasted into a NetBeans or VS Code project.
The only downside is that you have to create a project to paste the code into.
To do this follow the instructions in the book.
All of the programs below were copy and pasted from working programs in the IDE. They have been formatted using the built in formatter and hence are not identical in layout to the programs in the book. This is to make copy and pasting them easier. The programs in the book are formatted to be easy to read on the page.
Also notice that you will find complete listings of programs that are only slighly modified in the book and therefore not includes as a complete listing.The CMakeLists and other configuration files are also included here for completeness.
If anything you consider important is missing or if you have any requests or comments contact:
This email address is being protected from spambots. You need JavaScript enabled to view it.
CHAPTER 1
Page 20 WiFi Simple Connect Main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
int setup(uint32_t country, const char *ssid, const char *pass, uint32_t auth)
{
if (cyw43_arch_init_with_country(country))
{
return 1;
}
cyw43_arch_enable_sta_mode();
if (cyw43_arch_wifi_connect_blocking(ssid, pass, auth))
{
return 2;
}
}
char ssid[] = "myhost";
char pass[] = "mypassword";
uint32_t country = CYW43_COUNTRY_mycountry;
uint32_t auth = CYW43_AUTH_WPA2_MIXED_PSK;
int main()
{
stdio_init_all();
setup(country, ssid, pass, auth);
while (true)
{
sleep_ms(1);
}
}
Page 21 WiFi Connect CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background )
pico_add_extra_outputs(main)
Page 21 WiFi Connect lwiopts.h - basic configuration file not listed in book
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#endif /* __LWIPOPTS_H__ */
Page 25 WiFi Connect setupWifi.h - used in most examples to connect to the AP.
int setup(uint32_t country, const char *ssid, const char *pass,
uint32_t auth, const char *hostname, ip_addr_t *ip,
ip_addr_t *mask, ip_addr_t *gw)
{
if (cyw43_arch_init_with_country(country))
{
return 1;
}
cyw43_arch_enable_sta_mode();
if (hostname != NULL)
{
netif_set_hostname(netif_default, hostname);
}
if (cyw43_arch_wifi_connect_async(ssid, pass, auth))
{
return 2;
}
int flashrate = 1000;
int status = CYW43_LINK_UP + 1;
while (status >= 0 && status != CYW43_LINK_UP)
{
int new_status = cyw43_tcpip_link_status(&cyw43_state,
CYW43_ITF_STA);
if (new_status != status)
{
status = new_status;
flashrate = flashrate / (status + 1);
printf("connect status: %d %d\n", status, flashrate);
}
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
sleep_ms(flashrate);
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
sleep_ms(flashrate);
}
if (status < 0)
{
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
}
else
{
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
if (ip != NULL)
{
netif_set_ipaddr(netif_default, ip);
}
if (mask != NULL)
{
netif_set_netmask(netif_default, mask);
}
if (gw != NULL)
{
netif_set_gw(netif_default, gw);
}
printf("IP: %s\n",
ip4addr_ntoa(netif_ip_addr4(netif_default)));
printf("Mask: %s\n",
ip4addr_ntoa(netif_ip_netmask4(netif_default)));
printf("Gateway: %s\n",
ip4addr_ntoa(netif_ip_gw4(netif_default)));
printf("Host Name: %s\n",
netif_get_hostname(netif_default));
}
return status;
}
int connect()
{
char ssid[] = "ssid";
char pass[] = "password";
uint32_t country = CYW43_COUNTRY_code;
uint32_t auth = CYW43_AUTH_WPA2_MIXED_PSK;
return setup(country, ssid, pass, auth, "MyPicoW", NULL, NULL, NULL);
}
Page 28 Scan main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
static int scan_result(void *env, const cyw43_ev_scan_result_t *result)
{
if (result)
{
printf("ssid: %-32s rssi: %4d chan: %3d mac: %02x:%02x:%02x:%02x:%02x:%02x sec: %u\n",
result->ssid, result->rssi, result->channel,
result->bssid[0], result->bssid[1], result->bssid[2], result->bssid[3], result->bssid[4], result->bssid[5],
result->auth_mode);
}
return 0;
}
int main()
{
stdio_init_all();
if (cyw43_arch_init())
{
printf("failed to initialise\n");
return 1;
}
cyw43_arch_enable_sta_mode();
cyw43_wifi_set_up(&cyw43_state, CYW43_ITF_STA, true, CYW43_COUNTRY_UK);
cyw43_wifi_scan_options_t scan_options = {0};
int err = cyw43_wifi_scan(&cyw43_state, &scan_options, NULL, scan_result);
while (true)
{
if (!cyw43_wifi_scan_active(&cyw43_state))
break;
sleep_ms(1000);
printf("Scan in progress \n");
}
printf("Scan Complete\n");
cyw43_arch_deinit();
return 0;
}
Page 29 Get RSSI main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
int main()
{
stdio_init_all();
connect();
int32_t rssi;
while (true)
{
sleep_ms(1000);
cyw43_wifi_get_rssi(&cyw43_state, &rssi);
printf("rssi: %d \n", rssi);
}
}
Chapter 2
Page 38 Python HTTP Server
from http.server import HTTPServer, BaseHTTPRequestHandler
from io import BytesIO
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def sendResponse(self, cmd):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length)
self.send_response(200)
self.end_headers()
response = BytesIO()
response.write(b'This is a '+bytes(cmd, 'utf-8')+
b' request. ')
response.write(b'Received: ')
response.write(body)
self.wfile.write(response.getvalue())
def do_GET(self):
self.send_response(200)
self.end_headers()
self.wfile.write(b'Hello, world!')
def do_HEAD(self):
self.send_response(200)
self.end_headers()
def do_POST(self):
self.sendResponse("POST")
def do_PUT(self):
self.sendResponse("PUT")
def do_DELETE(self):
self.sendResponse("DELETE")
def do_PATCH(self):
self.sendResponse("PATCH")
httpd = HTTPServer(('', 8080), SimpleHTTPRequestHandler)
httpd.serve_forever()
Page 42 Simple HTTP Client using standard lwipopts.h and cmakelists.txt
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "lwip/tcp.h"
#define BUF_SIZE 2048
char myBuff[BUF_SIZE];
char header[] = "GET /index.html HTTP/1.1\r\nHOST:example.com\r\nConnection: close\r\n\r\n";
err_t recv(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
{
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
myBuff[p->tot_len] = 0;
printf("Buffer= %s\n", myBuff);
tcp_recved(pcb, p->tot_len);
pbuf_free(p);
}
return ERR_OK;
}
static err_t connected(void *arg, struct tcp_pcb *pcb, err_t err)
{
err = tcp_write(pcb, header, strlen(header), 0);
err = tcp_output(pcb);
return ERR_OK;
}
int main()
{
stdio_init_all();
connect();
struct tcp_pcb *pcb = tcp_new();
tcp_recv(pcb, recv);
ip_addr_t ip;
IP4_ADDR(&ip, 93, 184, 216, 34);
cyw43_arch_lwip_begin();
err_t err = tcp_connect(pcb, &ip, 80, connected);
cyw43_arch_lwip_end();
while (true)
{
sleep_ms(500);
}
}
Page 44 Simple HTTP Client Using ALTCP
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "lwip/altcp.h"
#define BUF_SIZE 2048
char myBuff[BUF_SIZE];
char header[] = "GET /index.html HTTP/1.1\r\nHOST:example.com\r\n\r\n";
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
myBuff[p->tot_len] = 0;
printf("Buffer= %s\n", myBuff);
altcp_recved(pcb, p->tot_len);
pbuf_free(p);
}
return ERR_OK;
}
static err_t altcp_client_connected(void *arg, struct altcp_pcb *pcb, err_t err)
{
err = altcp_write(pcb, header, strlen(header), 0);
err = altcp_output(pcb);
return ERR_OK;
}
int main()
{
stdio_init_all();
connect();
struct altcp_pcb *pcb = altcp_new(NULL);
altcp_recv(pcb, recv);
ip_addr_t ip;
IP4_ADDR(&ip, 93, 184, 216, 34);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(pcb, &ip, 80, altcp_client_connected);
cyw43_arch_lwip_end();
while (true)
{
sleep_ms(500);
}
}
Add to the end of lwipopts.h
#define LWIP_ALTCP 1
Page 45 Not listed in full in book
Final Practical HTTP Client main.c - standard cmakelists.txt and lwipopts.h with #define LWIP_ALTCP 1
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "lwip/altcp.h"
#define BUF_SIZE 2048
char myBuff[BUF_SIZE];
char header[] = "GET /index.html HTTP/1.1\r\nHOST:example.com\r\n\r\n";
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
if ((p->tot_len) > 2)
{
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
myBuff[p->tot_len] = 0;
printf("Buffer= %s\n", myBuff);
altcp_recved(pcb, p->tot_len);
}
pbuf_free(p);
} else
{
printf("Connection Closed");
altcp_close(pcb);
}
return ERR_OK;
}
err_t sent(void *arg, struct altcp_pcb *pcb, u16_t len)
{
printf("data sent %d\n", len);
}
void err(void *arg, err_t err)
{
if (err != ERR_ABRT)
{
printf("client_err %d\n", err);
}
}
err_t altcp_client_connected(void *arg, struct altcp_pcb *pcb, err_t err)
{
err = altcp_write(pcb, header, strlen(header), 0);
err = altcp_output(pcb);
return ERR_OK;
}
err_t poll(void *arg, struct altcp_pcb *pcb){
printf("Connection Closed");
altcp_close(pcb);
}
int main()
{
stdio_init_all();
connect();
struct altcp_pcb *pcb = altcp_new(NULL);
altcp_recv(pcb, recv);
altcp_sent(pcb, sent);
altcp_err(pcb, err);
altcp_poll(pcb, poll,10);
ip_addr_t ip;
IP4_ADDR(&ip, 93, 184, 216, 34);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(pcb, &ip, 80, altcp_client_connected);
cyw43_arch_lwip_end();
while (true)
{
sleep_ms(500);
}
}
Chapter 3
Page 54 Not listed in full in book
Simple integer state request
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "lwip/altcp.h"
#define BUF_SIZE 2048
char myBuff[BUF_SIZE];
char header[] = "GET /index.html HTTP/1.1\r\nHOST:example.com\r\n\r\n";
err_t sent(void *arg, struct altcp_pcb *pcb, u16_t len)
{
printf("data sent %d\n", len);
}
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
if ((p->tot_len) > 2)
{
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
myBuff[p->tot_len] = 0;
*(int *)arg = 4;
altcp_recved(pcb, p->tot_len);
}
pbuf_free(p);
}
else
{
printf("Connection Closed \n");
altcp_close(pcb);
*(int *)arg = 6;
}
return ERR_OK;
}
static err_t altcp_client_connected(void *arg, struct altcp_pcb *pcb, err_t err)
{
*(int *)arg = 2;
return ERR_OK;
}
err_t poll(void *arg, struct altcp_pcb *pcb)
{
printf("Connection Closed \n");
*(int *)arg = 6;
altcp_close(pcb);
}
void err(void *arg, err_t err)
{
if (err != ERR_ABRT)
{
printf("client_err %d\n", err);
}
}
int main()
{
stdio_init_all();
connect();
int state = 0;
struct altcp_pcb *pcb = altcp_new(NULL);
altcp_recv(pcb, recv);
altcp_sent(pcb, sent);
altcp_err(pcb, err);
altcp_poll(pcb, poll, 10);
altcp_arg(pcb, &state);
ip_addr_t ip;
IP4_ADDR(&ip, 93, 184, 216, 34);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(pcb, &ip, 80, altcp_client_connected);
cyw43_arch_lwip_end();
state = 1;
while (state != 0)
{
switch (state)
{
case 0:
case 1:
case 3:
break;
case 2:
state = 3;
cyw43_arch_lwip_begin();
err = altcp_write(pcb, header, strlen(header), 0);
err = altcp_output(pcb);
cyw43_arch_lwip_end();
break;
case 4:
state = 5;
break;
case 6:
printf("Buffer= %s\n", myBuff);
state = 0;
break;
default:
sleep_ms(1000);
printf("LED Flash\n");
}
}
printf("Data Transfered\n");
}
Page 59 State use a struct
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "lwip/altcp.h"
#define BUF_SIZE 2048
char myBuff[BUF_SIZE];
char header[] = "GET /index.html HTTP/1.1\r\nHOST:example.com\r\n\r\n";
struct connectionState
{
int state;
struct altcp_pcb *pcb;
char *myBuff;
int start;
};
err_t sent(void *arg, struct altcp_pcb *pcb, u16_t len)
{
printf("data sent %d\n", len);
}
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
struct connectionState *cs = (struct connectionState *)arg;
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
if ((p->tot_len) > 2)
{
pbuf_copy_partial(p, (cs->myBuff) + (cs->start), p->tot_len, 0);
cs->start += p->tot_len;
cs->myBuff[cs->start] = 0;
cs->state = 4;
altcp_recved(pcb, p->tot_len);
}
pbuf_free(p);
}
else
{
printf("Connection Closed\n");
altcp_close(pcb);
cs->state = 6;
}
return ERR_OK;
}
static err_t connected(void *arg, struct altcp_pcb *pcb, err_t err)
{
struct connectionState *cs = (struct connectionState *)arg;
cs->state = 2;
return ERR_OK;
}
err_t poll(void *arg, struct altcp_pcb *pcb)
{
printf("Connection Closed \n");
struct connectionState *cs = (struct connectionState *)arg;
cs->state = 6;
altcp_close(pcb);
}
void err(void *arg, err_t err)
{
if (err != ERR_ABRT)
{
printf("client_err %d\n", err);
}
}
err_t newConnection(struct connectionState *cs, char *buf)
{
cs->state = 0;
cs->pcb = altcp_new(NULL);
altcp_recv(cs->pcb, recv);
altcp_sent(cs->pcb, sent);
altcp_err(cs->pcb, err);
altcp_poll(cs->pcb, poll, 10);
altcp_arg(cs->pcb, cs);
cs->myBuff = buf;
cs->start = 0;
return ERR_OK;
}
int pollConnection(struct connectionState *cs)
{
switch (cs->state)
{
case 0:
case 1:
case 3:
case 6:
break;
case 2:
cs->state = 3;
cyw43_arch_lwip_begin();
err_t err = altcp_write(cs->pcb, header, strlen(header), 0);
err = altcp_output(cs->pcb);
cyw43_arch_lwip_end();
break;
case 4:
cs->state = 5;
break;
}
return cs->state;
}
int main()
{
stdio_init_all();
connect();
struct connectionState cs;
newConnection(&cs, myBuff);
ip_addr_t ip;
IP4_ADDR(&ip, 93, 184, 216, 34);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(cs.pcb, &ip, 80, connected);
cyw43_arch_lwip_end();
cs.state = 1;
while (true)
{
if (pollConnection(&cs) == 6)
{
printf("Buffer= %s\n", cs.myBuff);
cs.state = 0;
break;
}
sleep_ms(1000);
printf("LED Flash\n");
}
printf("Data Transfered\n");
}
Page 65 Non blocking general Request.h
struct connectionState
{
int state;
struct altcp_pcb *pcb;
char *sendData;
char *recvData;
int start;
};
err_t sent(void *arg, struct altcp_pcb *pcb, u16_t len)
{
printf("data sent %d\n", len);
}
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
struct connectionState *cs = (struct connectionState *)arg;
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
if ((p->tot_len) > 2)
{
pbuf_copy_partial(p, (cs->recvData) + (cs->start), p->tot_len, 0);
cs->start += p->tot_len;
cs->recvData[cs->start] = 0;
cs->state = 4;
altcp_recved(pcb, p->tot_len);
}
pbuf_free(p);
}
else
{
cs->state = 6;
}
return ERR_OK;
}
static err_t connected(void *arg, struct altcp_pcb *pcb, err_t err)
{
struct connectionState *cs = (struct connectionState *)arg;
cs->state = 2;
return ERR_OK;
}
err_t poll(void *arg, struct altcp_pcb *pcb)
{
printf("Connection Closed \n");
struct connectionState *cs = (struct connectionState *)arg;
cs->state = 6;
}
void err(void *arg, err_t err)
{
if (err != ERR_ABRT)
{
printf("client_err %d\n", err);
}
}
struct connectionState *newConnection(char *sendData, char *recvData)
{
struct connectionState *cs = (struct connectionState *)malloc(sizeof(struct connectionState));
cs->state = 0;
cs->pcb = altcp_new(NULL);
altcp_recv(cs->pcb, recv);
altcp_sent(cs->pcb, sent);
altcp_err(cs->pcb, err);
altcp_poll(cs->pcb, poll, 10);
altcp_arg(cs->pcb, cs);
cs->sendData = sendData;
cs->recvData = recvData;
cs->start = 0;
return cs;
}
struct connectionState *doRequest(ip_addr_t *ip, char *host, u16_t port, char *request, char *file, char *sendData, char *recvData)
{
char headerTemplate[] = "%s %s HTTP/1.1\r\nHOST:%s:%d\r\nConnection: close\r\nContent-length: %d\r\n\r\n%s";
int len = snprintf(NULL, 0, headerTemplate, request, file, host, port, strlen(sendData), sendData);
char *requestData = malloc(len + 1);
snprintf(requestData, len + 1, headerTemplate, request, file, host, port, strlen(sendData), sendData);
struct connectionState *cs = newConnection(requestData, recvData);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(cs->pcb, ip, port, connected);
cyw43_arch_lwip_end();
cs->state = 1;
return cs;
}
int pollRequest(struct connectionState **pcs)
{
if(*pcs==NULL) return 0;
struct connectionState *cs=*pcs;
switch (cs->state)
{
case 0:
case 1:
case 3:
break;
case 2:
cs->state = 3;
cyw43_arch_lwip_begin();
err_t err = altcp_write(cs->pcb, cs->sendData, strlen(cs->sendData), 0);
err = altcp_output(cs->pcb);
cyw43_arch_lwip_end();
break;
case 4:
cs->state = 5;
break;
case 6:
cyw43_arch_lwip_begin();
altcp_close(cs->pcb);
cyw43_arch_lwip_end();
free(cs);
*pcs = NULL;
return 0;
}
return cs->state;
}
Page 27 Non blocking Request main program downloading two requests.
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/altcp.h"
#include "setupWifi.h"
#include "request.h"
#define BUF_SIZE 2048
char myBuff1[BUF_SIZE];
char myBuff2[BUF_SIZE];
int main()
{
stdio_init_all();
connect();
ip_addr_t ip;
IP4_ADDR(&ip, 93, 184, 216, 34);
struct connectionState *cs1 = doRequest(&ip, "example.com", 80, "GET", "/", NULL, myBuff1);
IP4_ADDR(&ip, 192, 168, 11, 101);
struct connectionState *cs2 = doRequest(&ip, "192.168.11.101", 8080, "PUT", "/", "Hello PUT world", myBuff2);
while (pollRequest(&cs1) + pollRequest(&cs2))
{
sleep_ms(100);
}
printf("Both complete\n");
printf("Buffer 1 = \n%s\n\n", myBuff1);
printf("Buffer 2 = \n%s\n\n", myBuff2);
printf("Data Transferred\n");
cyw43_arch_deinit();
return 0;
}
Page 70 Temperature PUT client main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "lwip/altcp.h"
#include "request.h"
#define BUF_SIZE 4096
char myBuff1[BUF_SIZE];
int readTemp()
{
return 33;
}
int main()
{
char ssid[] = "laribina";
char pass[] = "hawkhawk";
uint32_t country = CYW43_COUNTRY_UK;
uint32_t auth = CYW43_AUTH_WPA2_MIXED_PSK;
stdio_init_all();
setup(country, ssid, pass, auth, "MyPicoW", NULL, NULL, NULL);
ip_addr_t ip;
IP4_ADDR(&ip, 192, 168, 11, 101);
while (true)
{
int t = readTemp();
int len = snprintf(NULL, 0, "%d", t);
char *requestData = malloc(len + 1);
snprintf(requestData, len + 1, "%d", t);
printf("%s\n",requestData);
struct connectionState *cs1 = doRequest(&ip, "192.168.11.101", 8080, "PUT", "/", requestData, myBuff1);
while (pollRequest(&cs1) )
{
sleep_ms(200);
}
printf("%s\n",myBuff1);
sleep_ms(5000);
}
return 0;
}
Page 71 Custom Sever For the PUT Temperature Client
from http.server import HTTPServer, BaseHTTPRequestHandler
from io import BytesIO
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def log_message(self,*args, **kwargs):
pass
def do_PUT(self):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length)
bodyString= body.decode(encoding="utf-8")
temp=float(bodyString)
print(temp,"C")
self.send_response(200)
self.end_headers()
httpd = HTTPServer(('', 8080), SimpleHTTPRequestHandler)
httpd.serve_forever()
Page 72 full listing not in book
Binary request version of request.h
struct connectionState
{
int state;
struct altcp_pcb *pcb;
char *sendData;
int bytes;
char *recvData;
int start;
};
err_t sent(void *arg, struct altcp_pcb *pcb, u16_t len)
{
printf("data sent %d\n", len);
}
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
struct connectionState *cs = (struct connectionState *)arg;
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
if ((p->tot_len) > 2)
{
pbuf_copy_partial(p, (cs->recvData) + (cs->start), p->tot_len, 0);
cs->start += p->tot_len;
cs->recvData[cs->start] = 0;
cs->state = 4;
altcp_recved(pcb, p->tot_len);
}
pbuf_free(p);
}
else
{
cs->state = 6;
}
return ERR_OK;
}
static err_t connected(void *arg, struct altcp_pcb *pcb, err_t err)
{
struct connectionState *cs = (struct connectionState *)arg;
cs->state = 2;
return ERR_OK;
}
err_t poll(void *arg, struct altcp_pcb *pcb)
{
printf("Connection Closed \n");
struct connectionState *cs = (struct connectionState *)arg;
cs->state = 6;
}
void err(void *arg, err_t err)
{
if (err != ERR_ABRT)
{
printf("client_err %d\n", err);
}
}
struct connectionState *newConnection(char *sendData, int bytes, char *recvData)
{
struct connectionState *cs = (struct connectionState *)malloc(sizeof(struct connectionState));
cs->state = 0;
cs->pcb = altcp_new(NULL);
altcp_recv(cs->pcb, recv);
altcp_sent(cs->pcb, sent);
altcp_err(cs->pcb, err);
altcp_poll(cs->pcb, poll, 10);
altcp_arg(cs->pcb, cs);
cs->sendData = sendData;
cs->bytes=bytes;
cs->recvData = recvData;
cs->start = 0;
return cs;
}
struct connectionState *doRequest(ip_addr_t *ip, char *host, u16_t port, char *request, char *file, char *sendData, char *recvData)
{
char headerTemplate[] = "%s %s HTTP/1.1\r\nHOST:%s:%d\r\nConnection: close\r\nContent-length: %d\r\n\r\n%s";
int len = snprintf(NULL, 0, headerTemplate, request, file, host, port, strlen(sendData), sendData);
char *requestData = malloc(len + 1);
snprintf(requestData, len + 1, headerTemplate, request, file, host, port, strlen(sendData), sendData);
struct connectionState *cs = newConnection(requestData, strlen(requestData),recvData);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(cs->pcb, ip, port, connected);
cyw43_arch_lwip_end();
cs->state = 1;
return cs;
}
struct connectionState *doRequestBinary(ip_addr_t *ip, char *host, u16_t port, char *request, char *file, char *sendData, int bytes, char *recvData)
{
char headerTemplate[] = "%s %s HTTP/1.1\r\nHOST:%s:%d\r\nConnection: close\r\nContent-length: %d\r\n\r\n";
int len = snprintf(NULL, 0, headerTemplate, request, file, host, port, bytes);
char *requestData = malloc(len + bytes + 1);
snprintf(requestData, len + 1, headerTemplate, request, file, host, port, bytes);
memcpy(requestData + len, sendData, bytes);
struct connectionState *cs = newConnection(requestData, len + bytes, recvData);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(cs->pcb, ip, port, connected);
cyw43_arch_lwip_end();
cs->state = 1;
return cs;
}
int pollRequest(struct connectionState **pcs)
{
if (*pcs == NULL)
return 0;
struct connectionState *cs = *pcs;
switch (cs->state)
{
case 0:
case 1:
case 3:
break;
case 2:
cs->state = 3;
cyw43_arch_lwip_begin();
err_t err = altcp_write(cs->pcb, cs->sendData, cs->bytes, 0);
err = altcp_output(cs->pcb);
cyw43_arch_lwip_end();
break;
case 4:
cs->state = 5;
break;
case 6:
cyw43_arch_lwip_begin();
altcp_close(cs->pcb);
cyw43_arch_lwip_end();
free(cs);
*pcs = NULL;
return 0;
}
return cs->state;
}
Page 74 Binary request main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "lwip/altcp.h"
#include "request.h"
#define BUF_SIZE 4096
char myBuff1[BUF_SIZE];
int main()
{
char ssid[] = "laribina";
char pass[] = "hawkhawk";
uint32_t country = CYW43_COUNTRY_UK;
uint32_t auth = CYW43_AUTH_WPA2_MIXED_PSK;
stdio_init_all();
setup(country, ssid, pass, auth, "MyPicoW", NULL, NULL, NULL);
char randdata[500];
ip_addr_t ip;
IP4_ADDR(&ip, 192, 168, 11, 101);
for (int p = 0; p < 500; p++)
{
randdata[p] = (uint8_t)rand();
}
struct connectionState *cs1 = doRequestBinary(&ip, "192.168.11.101", 8080, "PUT", "/", randdata, 500, myBuff1);
while (pollRequest(&cs1))
{
sleep_ms(200);
}
printf("%s\n", myBuff1);
return 0;
}
Page 75 Python Custom server for Binary request
from http.server import HTTPServer, BaseHTTPRequestHandler
from io import BytesIO
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def log_message(self,*args, **kwargs):
pass
def do_PUT(self):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length)
print(content_length)
with open("data.bin",mode="wb") as f:
f.write(body)
self.send_response(200)
self.end_headers()
response = BytesIO()
response.write(b'Received:' )
self.wfile.write(response.getvalue())
httpd = HTTPServer(('', 8080), SimpleHTTPRequestHandler)
httpd.serve_forever()
Page 77 full listing not in book
DNS Main Program needs requests.h
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/altcp.h"
#include "lwip/dns.h"
#include "setupWifi.h"
#include "request.h"
#define BUF_SIZE 2048
char myBuff1[BUF_SIZE];
void dns_found(const char *name, const ip_addr_t *ip, void *arg)
{
ip_addr_t *ipResult = (ip_addr_t *)arg;
if (ip)
{
ip4_addr_copy(*ipResult, *ip);
}
else
{
ip4_addr_set_loopback(ipResult);
}
return;
}
err_t getIP(char *URL, ip_addr_t *ipResult)
{
cyw43_arch_lwip_begin();
err_t err = dns_gethostbyname(URL, ipResult, dns_found, ipResult);
cyw43_arch_lwip_end();
return err;
}
int main()
{
stdio_init_all();
connect();
ip_addr_t ip;
ip4_addr_set_zero(&ip);
getIP("example.com", &ip);
while (!ip_addr_get_ip4_u32(&ip))
{
sleep_ms(100);
};
if (ip4_addr_isloopback(&ip))
{
printf("address not found");
}
struct connectionState *cs1 = doRequest(&ip, "example.com", 80, "GET", "/", NULL, myBuff1);
while (pollRequest(&cs1))
{
sleep_ms(100);
}
printf("Buffer 1 = \n%s\n\n", myBuff1);
printf("Data Transferred\n");
cyw43_arch_deinit();
return 0;
}
Chapter 4
Page 90 Simple TLS Client main.c
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/altcp.h"
#include "lwip/altcp_tls.h"
#include "setupWifi.h"
#define BUF_SIZE 2048
char myBuff[BUF_SIZE];
char header[] = "GET /index.html HTTP/1.1\r\nHOST:example.com\r\n\r\n";
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
myBuff[p->tot_len] = 0;
printf("Buffer= %s\n", myBuff);
altcp_recved(pcb, p->tot_len);
pbuf_free(p);
}
return ERR_OK;
}
static err_t altcp_client_connected(void *arg, struct altcp_pcb *pcb, err_t err)
{
err = altcp_write(pcb, header, strlen(header), 0);
err = altcp_output(pcb);
return ERR_OK;
}
int main()
{
stdio_init_all();
connect();
struct altcp_tls_config *tls_config = altcp_tls_create_config_client(NULL, 0);
struct altcp_pcb *pcb = altcp_tls_new(tls_config, IPADDR_TYPE_ANY);
mbedtls_ssl_set_hostname(altcp_tls_context(pcb), "example.com"); altcp_recv(pcb, recv);
ip_addr_t ip;
IP4_ADDR(&ip, 93, 184, 216, 34);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(pcb, &ip, 443, altcp_client_connected);
cyw43_arch_lwip_end();
while (true)
{
sleep_ms(500);
}
}
Page 90 Simple TLS Client cmakelists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background pico_lwip_mbedtls
pico_mbedtls)
pico_add_extra_outputs(main)
Page 88 Simple TLS Client mbedtls_config.h
//Hardware config
#define MBEDTLS_NO_PLATFORM_ENTROPY
#define MBEDTLS_ENTROPY_HARDWARE_ALT
#define MBEDTLS_HAVE_TIME
//error reporting
#define MBEDTLS_ERROR_C
//used by LwIP
#define MBEDTLS_ENTROPY_C
#define MBEDTLS_CTR_DRBG_C
//RSA KEY EXCHANGE
#define MBEDTLS_KEY_EXCHANGE_RSA_ENABLED
#define MBEDTLS_RSA_C
//general key exchange
#define MBEDTLS_PKCS1_V15
#define MBEDTLS_BIGNUM_C
#define MBEDTLS_PK_C
#define MBEDTLS_PK_PARSE_C
//encryption
#define MBEDTLS_AES_C
#define MBEDTLS_CCM_C
#define MBEDTLS_CIPHER_MODE_CBC
#define MBEDTLS_AES_FEWER_TABLES
//certs
#define MBEDTLS_X509_CRT_PARSE_C
#define MBEDTLS_X509_USE_C
#define MBEDTLS_OID_C
#define MBEDTLS_ASN1_PARSE_C
#define MBEDTLS_ASN1_WRITE_C
//hash methods
#define MBEDTLS_SHA1_C
#define MBEDTLS_SHA224_C
#define MBEDTLS_SHA256_C
#define MBEDTLS_SHA512_C
//TLS
#define MBEDTLS_CIPHER_C
#define MBEDTLS_SSL_TLS_C
#define MBEDTLS_MD_C
//enable client and server modes and TLS
#define MBEDTLS_SSL_CLI_C
#define MBEDTLS_SSL_SERVER_NAME_INDICATION
//enable TLS 1.2
#define MBEDTLS_SSL_PROTO_TLS1_2
#include "/home/pi/pico/pico-sdk/lib/mbedtls/include/mbedtls/check_config.h"
Page 90 full listing not in book
Simple TLS Client lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#define LWIP_ALTCP 1
#define LWIP_ALTCP_TLS 1
#define LWIP_ALTCP_TLS_MBEDTLS 1
#define LWIP_DEBUG 1
#define ALTCP_MBEDTLS_DEBUG LWIP_DBG_ON
#endif /* __LWIPOPTS_H__ */
Page 92 Full listing not in book
TLS Request.h
struct connectionState
{
int state;
struct altcp_pcb *pcb;
char *sendData;
int bytes;
char *recvData;
int start;
};
err_t sent(void *arg, struct altcp_pcb *pcb, u16_t len)
{
printf("data sent %d\n", len);
}
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
struct connectionState *cs = (struct connectionState *)arg;
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
if ((p->tot_len) > 2)
{
pbuf_copy_partial(p, (cs->recvData) + (cs->start), p->tot_len, 0);
cs->start += p->tot_len;
cs->recvData[cs->start] = 0;
cs->state = 4;
altcp_recved(pcb, p->tot_len);
}
pbuf_free(p);
}
else
{
cs->state = 6;
}
return ERR_OK;
}
static err_t connected(void *arg, struct altcp_pcb *pcb, err_t err)
{
struct connectionState *cs = (struct connectionState *)arg;
cs->state = 2;
return ERR_OK;
}
err_t poll(void *arg, struct altcp_pcb *pcb)
{
printf("Connection Closed \n");
struct connectionState *cs = (struct connectionState *)arg;
cs->state = 6;
}
void err(void *arg, err_t err)
{
if (err != ERR_ABRT)
{
printf("client_err %d\n", err);
}
}
struct connectionState *newConnection(char *sendData, int bytes, char *recvData)
{
struct connectionState *cs = (struct connectionState *)malloc(sizeof(struct connectionState));
cs->state = 0;
cs->pcb = altcp_new(NULL);
altcp_recv(cs->pcb, recv);
altcp_sent(cs->pcb, sent);
altcp_err(cs->pcb, err);
altcp_poll(cs->pcb, poll, 10);
altcp_arg(cs->pcb, cs);
cs->sendData = sendData;
cs->bytes=bytes;
cs->recvData = recvData;
cs->start = 0;
return cs;
}
struct connectionState *newTLSConnection(char* host, char *sendData, int bytes, char *recvData)
{
struct connectionState *cs = (struct connectionState *)malloc(sizeof(struct connectionState));
cs->state = 0;
struct altcp_tls_config *tls_config = altcp_tls_create_config_client(NULL, 0);
cs->pcb = altcp_tls_new(tls_config, IPADDR_TYPE_ANY);
mbedtls_ssl_set_hostname(altcp_tls_context(cs->pcb), host);
altcp_recv(cs->pcb, recv);
altcp_sent(cs->pcb, sent);
altcp_err(cs->pcb, err);
altcp_poll(cs->pcb, poll, 10);
altcp_arg(cs->pcb, cs);
cs->sendData = sendData;
cs->bytes=bytes;
cs->recvData = recvData;
cs->start = 0;
return cs;
}
struct connectionState *doRequest(ip_addr_t *ip, char *host, u16_t port, char *request, char *file, char *sendData, char *recvData)
{
char headerTemplate[] = "%s %s HTTP/1.1\r\nHOST:%s:%d\r\nConnection: close\r\nContent-length: %d\r\n\r\n%s";
int len = snprintf(NULL, 0, headerTemplate, request, file, host, port, strlen(sendData), sendData);
char *requestData = malloc(len + 1);
snprintf(requestData, len + 1, headerTemplate, request, file, host, port, strlen(sendData), sendData);
struct connectionState *cs = newConnection(requestData, strlen(requestData),recvData);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(cs->pcb, ip, port, connected);
cyw43_arch_lwip_end();
cs->state = 1;
return cs;
}
struct connectionState *doRequestBinary(ip_addr_t *ip, char *host, u16_t port, char *request, char *file, char *sendData, int bytes, char *recvData)
{
char headerTemplate[] = "%s %s HTTP/1.1\r\nHOST:%s:%d\r\nConnection: close\r\nContent-length: %d\r\n\r\n";
int len = snprintf(NULL, 0, headerTemplate, request, file, host, port, bytes);
char *requestData = malloc(len + bytes + 1);
snprintf(requestData, len + 1, headerTemplate, request, file, host, port, bytes);
memcpy(requestData + len, sendData, bytes);
struct connectionState *cs = newConnection(requestData, len + bytes, recvData);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(cs->pcb, ip, port, connected);
cyw43_arch_lwip_end();
cs->state = 1;
return cs;
}
struct connectionState *doTLSRequestBinary(ip_addr_t *ip, char *host, u16_t port, char *request, char *file, char *sendData,int bytes, char *recvData)
{
char headerTemplate[] = "%s %s HTTP/1.1\r\nHOST:%s:%d\r\nConnection: close\r\nContent-length: %d\r\n\r\n";
int len = snprintf(NULL, 0, headerTemplate, request, file, host, port, bytes);
char *requestData = malloc(len + bytes+1);
snprintf(requestData, len+1, headerTemplate, request, file, host, port, bytes);
memcpy(requestData+len,sendData,bytes);
struct connectionState *cs = newTLSConnection(host,requestData,len+bytes ,recvData);
cyw43_arch_lwip_begin();
err_t err = altcp_connect(cs->pcb, ip, port, connected);
cyw43_arch_lwip_end();
cs->state = 1;
return cs;
}
int pollRequest(struct connectionState **pcs)
{
if (*pcs == NULL)
return 0;
struct connectionState *cs = *pcs;
switch (cs->state)
{
case 0:
case 1:
case 3:
break;
case 2:
cs->state = 3;
cyw43_arch_lwip_begin();
err_t err = altcp_write(cs->pcb, cs->sendData, cs->bytes, 0);
err = altcp_output(cs->pcb);
cyw43_arch_lwip_end();
break;
case 4:
cs->state = 5;
break;
case 6:
cyw43_arch_lwip_begin();
altcp_close(cs->pcb);
cyw43_arch_lwip_end();
free(cs);
*pcs = NULL;
return 0;
}
return cs->state;
}
Page 94 RequestTLS Client Main.c
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/pbuf.h"
#include "lwip/altcp_tcp.h"
#include "lwip/altcp_tls.h"
#include "setupWifi.h"
#include "request.h"
#define BUF_SIZE 2048
char myBuff[BUF_SIZE];
int main()
{
stdio_init_all();
connect();
ip_addr_t ip;
IP4_ADDR(&ip, 93, 184, 216, 34);
struct connectionState *cs1 = doTLSRequestBinary(&ip, "example.com", 443, "GET", "/", NULL, 0, myBuff);
while (pollRequest(&cs1))
{
sleep_ms(200);
}
printf("%s\n", myBuff);
return 0;
}
Chapter 5
Page 105 RandomByte function
uint8_t randomByte()
{
uint32_t random = 0;
uint32_t bit = 0;
for (int k = 0; k < 8; k++)
{
while (true)
{
bit = rosc_hw->randombit;
sleep_us(10);
if (bit != rosc_hw->randombit)
break;
}
random = (random << 1) | bit;
}
return (uint8_t)random;
}
Page 111 Full listing not in book
Adding EC and GCM to mbedtls_config.h in Client and server mode
//Hardware config
#define MBEDTLS_NO_PLATFORM_ENTROPY
#define MBEDTLS_ENTROPY_HARDWARE_ALT
#define MBEDTLS_HAVE_TIME
//error reporting
#define MBEDTLS_ERROR_C
//used by LwIP
#define MBEDTLS_ENTROPY_C
#define MBEDTLS_CTR_DRBG_C
//EC KEY EXCHANGE
#define MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED
#define MBEDTLS_ECDH_C
#define MBEDTLS_ECDSA_C
#define MBEDTLS_ECP_C
/* Short Weierstrass curves (supporting ECP, ECDH, ECDSA) */
#define MBEDTLS_ECP_DP_SECP192R1_ENABLED
#define MBEDTLS_ECP_DP_SECP224R1_ENABLED
#define MBEDTLS_ECP_DP_SECP256R1_ENABLED
#define MBEDTLS_ECP_DP_SECP384R1_ENABLED
#define MBEDTLS_ECP_DP_SECP521R1_ENABLED
#define MBEDTLS_ECP_DP_SECP192K1_ENABLED
#define MBEDTLS_ECP_DP_SECP224K1_ENABLED
#define MBEDTLS_ECP_DP_SECP256K1_ENABLED
#define MBEDTLS_ECP_DP_BP256R1_ENABLED
#define MBEDTLS_ECP_DP_BP384R1_ENABLED
#define MBEDTLS_ECP_DP_BP512R1_ENABLED
//RSA KEY EXCHANGE
#define MBEDTLS_KEY_EXCHANGE_RSA_ENABLED
#define MBEDTLS_RSA_C
//general key exchange
#define MBEDTLS_PKCS1_V15
#define MBEDTLS_BIGNUM_C
#define MBEDTLS_PK_C
#define MBEDTLS_PK_PARSE_C
//encryption
#define MBEDTLS_AES_C
#define MBEDTLS_CCM_C
#define MBEDTLS_CIPHER_MODE_CBC
#define MBEDTLS_AES_FEWER_TABLES
#define MBEDTLS_GCM_C
//certs
#define MBEDTLS_X509_CRT_PARSE_C
#define MBEDTLS_X509_USE_C
#define MBEDTLS_OID_C
#define MBEDTLS_ASN1_PARSE_C
#define MBEDTLS_ASN1_WRITE_C
//hash methods
#define MBEDTLS_SHA1_C
#define MBEDTLS_SHA224_C
#define MBEDTLS_SHA256_C
#define MBEDTLS_SHA512_C
//TLS
#define MBEDTLS_CIPHER_C
#define MBEDTLS_SSL_TLS_C
#define MBEDTLS_MD_C
//enable client and server modes and TLS
#define MBEDTLS_SSL_CLI_C
#define MBEDTLS_SSL_SERVER_NAME_INDICATION
#define MBEDTLS_SSL_SRV_C
//enable TLS 1.2
#define MBEDTLS_SSL_PROTO_TLS1_2
#include "/home/pi/pico/pico-sdk/lib/mbedtls/include/mbedtls/check_config.h"
Page 115 AES ECB Mode Main Program
#include <stdio.h>
#include "pico/stdlib.h"
#include "mbedtls/cipher.h"
#include "pico/rand.h"
int main()
{
stdio_init_all();
int ret;
mbedtls_cipher_context_t cipher_ctx;
mbedtls_cipher_init(&cipher_ctx);
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_string("AES-128-ECB");
ret = mbedtls_cipher_setup(&cipher_ctx, cipher_info);
unsigned char key[16];
get_rand_128((rng_128_t*)key );
ret = mbedtls_cipher_setkey(&cipher_ctx, key, cipher_info->key_bitlen, MBEDTLS_ENCRYPT);
ret = mbedtls_cipher_reset(&cipher_ctx);
char buffer[16] = "Hello World";
char output[16];
int olen;
ret = mbedtls_cipher_update(&cipher_ctx, buffer, 16, output, &olen);
printf("cipher text ");
for (int i = 0; i < olen; i++)
{
printf("%02X", output[i]);
}
printf("\n");
char plaintext[16];
ret = mbedtls_cipher_setkey(&cipher_ctx, key, cipher_info->key_bitlen, MBEDTLS_DECRYPT);
ret = mbedtls_cipher_reset(&cipher_ctx);
mbedtls_cipher_update(&cipher_ctx, output, 16, plaintext, &olen);
printf("plain text %.16s\n", plaintext);
return 0;
}
Page 116 AES ECB mbedtls_config.h
//Hardware config
#define MBEDTLS_NO_PLATFORM_ENTROPY
#define MBEDTLS_ENTROPY_HARDWARE_ALT
#define MBEDTLS_HAVE_TIME
//error reporting
#define MBEDTLS_ERROR_C
//encryption
#define MBEDTLS_AES_C
#define MBEDTLS_CCM_C
#define MBEDTLS_CIPHER_MODE_CBC
#define MBEDTLS_AES_FEWER_TABLES
#define MBEDTLS_CIPHER_C
#include "/home/pi/pico/pico-sdk/lib/mbedtls/include/mbedtls/check_config.h"
Page 116 AES ECB Mode CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_mbedtls)
pico_add_extra_outputs(main)
Page 118 Full listing not in book
AES CBC Mode Main Program including list of available encryptions.
#include <stdio.h>
#include "pico/stdlib.h"
#include "mbedtls/cipher.h"
#include "pico/rand.h"
int main()
{
stdio_init_all();
int ret;
const mbedtls_cipher_info_t *cipher_info1;
const int *list;
printf("Available ciphers:\n");
list = mbedtls_cipher_list();
while (*list)
{
cipher_info1 = mbedtls_cipher_info_from_type(*list);
printf(" %s\n", cipher_info1->name);
list++;
}
mbedtls_cipher_context_t cipher_ctx;
mbedtls_cipher_init(&cipher_ctx);
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_string("AES-128-CBC");
ret = mbedtls_cipher_setup(&cipher_ctx, cipher_info);
unsigned char key[16];
get_rand_128((rng_128_t *)key);
ret = mbedtls_cipher_setkey(&cipher_ctx, key, cipher_info->key_bitlen, MBEDTLS_ENCRYPT);
unsigned char IV[16];
get_rand_128((rng_128_t *)IV);
ret = mbedtls_cipher_set_iv(&cipher_ctx, IV, 16);
ret = mbedtls_cipher_reset(&cipher_ctx);
char buffer[16] = "Hello World";
char output[16];
int olen;
ret = mbedtls_cipher_update(&cipher_ctx, buffer, 16, output, &olen);
printf("cipher text ");
for (int i = 0; i < olen; i++)
{
printf("%02X", output[i]);
}
printf("\n");
char plaintext[16];
ret = mbedtls_cipher_setkey(&cipher_ctx, key, cipher_info->key_bitlen, MBEDTLS_DECRYPT);
ret = mbedtls_cipher_set_iv(&cipher_ctx, IV, 16);
ret = mbedtls_cipher_reset(&cipher_ctx);
ret = mbedtls_cipher_update(&cipher_ctx, output, 16, plaintext, &olen);
printf("plain text %.16s\n", plaintext);
return 0;
}
Chapter 6
Page 130 Simple HTTP Server Main Program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/pbuf.h"
#include "lwip/altcp_tcp.h"
#include "hardware/rtc.h"
#include "time.h"
#include "setupWifi.h"
#define BUF_SIZE 2048
void getDateNow(struct tm *t)
{
datetime_t rtc;
rtc_get_datetime(&rtc);
t->tm_sec = rtc.sec;
t->tm_min = rtc.min;
t->tm_hour = rtc.hour;
t->tm_mday = rtc.day;
t->tm_mon = rtc.month - 1;
t->tm_year = rtc.year - 1900;
t->tm_wday = rtc.dotw;
t->tm_yday = 0;
t->tm_isdst = -1;
}
void sendData(struct altcp_pcb *pcb)
{
err_t err;
char html[] = "<html><head><title>Temperature</title></head><body><p>{\"humidity\":81%, \"airtemperature\":23.5C}</p></body></html>\r\n";
char headers[1024] = {0};
char Status[] = "HTTP/1.1 200 OK\r\nContent-Type: text/html;charset=UTF-8\r\nServer:Picow\r\n";
struct tm t;
getDateNow(&t);
char Date[100];
strftime(Date, sizeof(Date), "Date: %a, %d %b %Y %k:%M:%S %Z\r\n", &t);
char ContLen[100] = {0};
snprintf(ContLen, sizeof ContLen, "Content-Length:%d \r\n", strlen(html));
snprintf(headers, sizeof headers, "%s%s%s\r\n", Status, Date, ContLen);
char data[2048] = {0};
snprintf(data, sizeof data, "%s%s", headers, html);
err = altcp_write(pcb, data, strlen(data), 0);
err = altcp_output(pcb);
}
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
char myBuff[BUF_SIZE];
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
myBuff[p->tot_len] = 0;
printf("Buffer= %s\n", myBuff);
altcp_recved(pcb, p->tot_len);
pbuf_free(p);
sendData(pcb);
}
return ERR_OK;
}
static err_t sent(void *arg, struct altcp_pcb *pcb, u16_t len)
{
altcp_close(pcb);
}
static err_t accept(void *arg, struct altcp_pcb *pcb, err_t err)
{
altcp_recv(pcb, recv);
altcp_sent(pcb, sent);
printf("connect!\n");
return ERR_OK;
}
void setRTC()
{
datetime_t t = {
.year = 2023,
.month = 02,
.day = 03,
.dotw = 5,
.hour = 11,
.min = 10,
.sec = 00};
rtc_init();
rtc_set_datetime(&t);
}
int main()
{
stdio_init_all();
setRTC();
connect();
struct altcp_pcb *pcb = altcp_new(NULL);
altcp_accept(pcb, accept);
altcp_bind(pcb, IP_ADDR_ANY, 80);
cyw43_arch_lwip_begin();
pcb = altcp_listen_with_backlog(pcb, 3);
cyw43_arch_lwip_end();
while (true)
{
sleep_ms(500);
}
}
Page 133 Full listing not in book
Simple HTTP Server lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#define LWIP_ALTCP 1
#define LWIP_DEBUG 1
#define TCP_LISTEN_BACKLOG 1
#endif /* __LWIPOPTS_H__ */
Page 113 Full listing not in book
Simple HTTP Server CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background hardware_rtc)
pico_add_extra_outputs(main)
Page 136 Python program to convert certificate to C code
import binascii
with open("iopress.key", 'rb') as f:
lines = f.readlines()
lines = b"".join(lines[1:-1])
key = binascii.a2b_base64(lines)
res = ""
for b in key:
res += "0x%02x," % b
res="u8_t key[]={"+res[:-1]+"};"
print(res)
with open("iopress.crt", 'rb') as f:
lines = f.readlines()
lines = b"".join(lines[1:-1])
cert = binascii.a2b_base64(lines)
res = ""
for b in cert:
res += "0x%02x," % b
res="u8_t cert[]={"+res[:-1]+"};"
print()
print(res)
Page 137 Full listing not in book
Simple HTTPS Server Main Program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/pbuf.h"
#include "lwip/altcp_tcp.h"
#include "lwip/altcp_tls.h"
#include "hardware/structs/rosc.h"
#include "hardware/rtc.h"
#include "time.h"
#include "setupWifi.h"
#define BUF_SIZE 2048
void getDateNow(struct tm *t)
{
datetime_t rtc;
rtc_get_datetime(&rtc);
t->tm_sec = rtc.sec;
t->tm_min = rtc.min;
t->tm_hour = rtc.hour;
t->tm_mday = rtc.day;
t->tm_mon = rtc.month - 1;
t->tm_year = rtc.year - 1900;
t->tm_wday = rtc.dotw;
t->tm_yday = 0;
t->tm_isdst = -1;
}
void sendData(struct altcp_pcb *pcb)
{
err_t err;
char html[] = "<html><head><title>Temperature</title></head><body><p>{\"humidity\":81%, \"airtemperature\":23.5C}</p></body></html>\r\n";
char headers[1024] = {0};
char Status[] = "HTTP/1.1 200 OK\r\nContent-Type: text/html;charset=UTF-8\r\nServer:Picow\r\n";
struct tm t;
getDateNow(&t);
char Date[100];
strftime(Date, sizeof(Date), "Date: %a, %d %b %Y %k:%M:%S %Z\r\n", &t);
char ContLen[100] = {0};
snprintf(ContLen, sizeof ContLen, "Content-Length:%d \r\n", strlen(html));
snprintf(headers, sizeof headers, "%s%s%s\r\n", Status, Date, ContLen);
char data[2048] = {0};
snprintf(data, sizeof data, "%s%s", headers, html);
err = altcp_write(pcb, data, strlen(data), 0);
err = altcp_output(pcb);
}
err_t recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
{
char myBuff[BUF_SIZE];
if (p != NULL)
{
printf("recv total %d this buffer %d next %d err %d\n", p->tot_len, p->len, p->next, err);
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
myBuff[p->tot_len] = 0;
printf("Buffer= %s\n", myBuff);
altcp_recved(pcb, p->tot_len);
pbuf_free(p);
sendData(pcb);
}
return ERR_OK;
}
static err_t sent(void *arg, struct altcp_pcb *pcb, u16_t len)
{
altcp_close(pcb);
}
static err_t accept(void *arg, struct altcp_pcb *pcb, err_t err)
{
altcp_recv(pcb, recv);
altcp_sent(pcb, sent);
printf("connect!\n");
return ERR_OK;
}
void setRTC()
{
datetime_t t = {
.year = 2023,
.month = 02,
.day = 03,
.dotw = 5,
.hour = 11,
.min = 10,
.sec = 00};
rtc_init();
rtc_set_datetime(&t);
}
int main()
{
stdio_init_all();
setRTC();
connect();
u8_t key[] = {0x30, 0x82, 0x04, 0xbd, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, 0x04, 0xa7, 0x30, 0x82, 0x04, 0xa3, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00, 0xbd, 0xb3, 0xb6, 0x94, 0x9f, 0x87, 0x85, 0xd6, 0xd4, 0xd0, 0xf9, 0x24, 0x4b, 0x8c, 0x7d, 0x9e, 0xf5, 0x83, 0xac, 0x90, 0x37, 0x5b, 0xdf, 0x4d, 0x9b, 0x05, 0x6b, 0x5f, 0xaa, 0x87, 0x31, 0x87, 0x0e, 0x97, 0x90, 0xa0, 0xff, 0x12, 0x81, 0xcc, 0xfe, 0x66, 0xa3, 0x8e, 0x34, 0x33, 0x63, 0x27, 0x10, 0xa4, 0xf1, 0x57, 0x27, 0x72, 0x54, 0x45, 0x41, 0x62, 0xee, 0x00, 0x36, 0xaa, 0x1f, 0xfa, 0xa3, 0xb0, 0x27, 0xeb, 0x3e, 0xf3, 0xcf, 0x04, 0x17, 0x68, 0x22, 0xf1, 0x1e, 0x1c, 0x9e, 0x27, 0x7d, 0x82, 0xb3, 0x3f, 0x3c, 0x12, 0x63, 0x94, 0x3b, 0xae, 0x87, 0x3c, 0x33, 0x6a, 0x08, 0x63, 0x84, 0xc2, 0xf8, 0x87, 0xbd, 0xfd, 0x25, 0x92, 0xb7, 0x8d, 0xdb, 0xac, 0xe9, 0xcb, 0x3f, 0x04, 0x3d, 0xee, 0x9f, 0xf6, 0x17, 0xbe, 0xea, 0x41, 0x7f, 0x2b, 0x2d, 0x4a, 0xbf, 0x64, 0xea, 0x01, 0x83, 0xf2, 0x59, 0x82, 0x6c, 0xcb, 0x6c, 0x1f, 0x91, 0x53, 0xde, 0x8a, 0x36, 0x7f, 0x41, 0x7e, 0x19, 0x02, 0x80, 0x42, 0x8c, 0xd5, 0xc1, 0x3c, 0x22, 0x06, 0xf4, 0x2d, 0x09, 0x45, 0xbf, 0xc1, 0x12, 0xe3, 0xfc, 0xa3, 0xc2, 0x89, 0x11, 0x7f, 0x01, 0xcb, 0x49, 0xab, 0xc1, 0x50, 0x37, 0xca, 0x03, 0xb7, 0x44, 0x94, 0x16, 0xbf, 0xd6, 0xf5, 0xa6, 0xbc, 0x10, 0x86, 0xf2, 0x97, 0xea, 0x66, 0x15, 0xa3, 0x9f, 0x4d, 0xf0, 0xe6, 0xa5, 0xfb, 0x1f, 0x25, 0xd7, 0x71, 0xed, 0x85, 0x53, 0x5b, 0x86, 0x1c, 0x46, 0x29, 0xb5, 0xa8, 0xa8, 0x25, 0x27, 0x5a, 0x51, 0x27, 0x30, 0xa7, 0x94, 0x07, 0x21, 0xf7, 0x66, 0xe2, 0xab, 0x16, 0x0e, 0x59, 0xa2, 0x7a, 0x70, 0x30, 0xba, 0x6b, 0x9f, 0xf9, 0x4d, 0x22, 0x4e, 0xa3, 0x33, 0x7e, 0x49, 0x43, 0x62, 0x29, 0xf5, 0xc7, 0x61, 0x7e, 0x5f, 0xcd, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01, 0x00, 0x1e, 0x04, 0x4b, 0xc5, 0xa4, 0xa0, 0x8b, 0x1a, 0xfd, 0x3d, 0xbb, 0xce, 0x74, 0x6d, 0xdc, 0x8a, 0xc4, 0x8a, 0x7b, 0x49, 0xae, 0x98, 0xc8, 0xf2, 0xbc, 0xae, 0xd4, 0xd8, 0xa4, 0x61, 0x14, 0x03, 0x2c, 0xd9, 0xea, 0xb6, 0xae, 0xe5, 0xbc, 0xc8, 0x35, 0x11, 0x04, 0x9c, 0x41, 0xc2, 0x47, 0xd4, 0x2c, 0x9c, 0x0c, 0xdc, 0x1f, 0x8f, 0xc5, 0xa9, 0xd7, 0xb8, 0xd1, 0xb4, 0x12, 0xf2, 0x44, 0x71, 0x22, 0x69, 0x83, 0x47, 0x84, 0x04, 0x8c, 0x23, 0x37, 0x98, 0xf0, 0xbe, 0x7a, 0x67, 0x48, 0xd7, 0x32, 0xd2, 0xf5, 0x8d, 0xf1, 0xf1, 0x6e, 0xf4, 0x4b, 0xa5, 0x48, 0x1c, 0xcc, 0x7d, 0xe0, 0xa9, 0xee, 0x9d, 0xf3, 0x39, 0x77, 0x64, 0x91, 0x07, 0x70, 0x27, 0xf0, 0x34, 0xa2, 0x21, 0xd8, 0xec, 0xd0, 0xe7, 0xeb, 0x43, 0xc3, 0x6a, 0x20, 0x23, 0x10, 0xfe, 0x42, 0x02, 0x6b, 0xda, 0x89, 0xf4, 0x41, 0x96, 0x64, 0x32, 0x52, 0x20, 0x05, 0x0d, 0x5b, 0xf3, 0x67, 0x51, 0xb7, 0x7d, 0xd1, 0x24, 0x0b, 0x2c, 0x33, 0x84, 0x5b, 0xf9, 0xed, 0x66, 0xe6, 0x3c, 0x4d, 0xdf, 0x09, 0x3e, 0xd5, 0xe5, 0x1c, 0x27, 0x2c, 0x81, 0xee, 0x03, 0x91, 0x8d, 0xc0, 0x2b, 0x3e, 0xd9, 0x37, 0x8e, 0x3d, 0xd1, 0x30, 0xd6, 0x97, 0x7b, 0x98, 0xfb, 0x80, 0x13, 0x5a, 0x84, 0x08, 0x90, 0x0d, 0x5c, 0x99, 0x51, 0x4f, 0x8f, 0xab, 0x0c, 0x39, 0x69, 0x76, 0xf8, 0xf4, 0xfd, 0xa7, 0x04, 0x8d, 0x72, 0x27, 0xa6, 0x1e, 0xbd, 0xff, 0x10, 0x43, 0xe8, 0x53, 0xe7, 0x08, 0xb8, 0xbd, 0x55, 0xb4, 0x7a, 0xa2, 0x44, 0xe9, 0xe7, 0x78, 0xf7, 0x11, 0x49, 0x01, 0x70, 0x60, 0xdf, 0xe8, 0xd1, 0xb0, 0x8c, 0xa2, 0x3d, 0x98, 0x07, 0x9b, 0x66, 0xff, 0xe8, 0x68, 0x33, 0x82, 0xe3, 0x75, 0x3d, 0x37, 0x8d, 0xf2, 0x41, 0x02, 0x81, 0x81, 0x00, 0xe8, 0xc0, 0x12, 0x7f, 0x02, 0x98, 0x75, 0x23, 0xa6, 0x32, 0x92, 0x4e, 0x11, 0x27, 0xad, 0xda, 0x5b, 0x9e, 0xec, 0x9c, 0xa4, 0xb4, 0x26, 0x2b, 0x2b, 0xd4, 0xdb, 0x1a, 0x9e, 0xd5, 0xd3, 0xa8, 0xb4, 0x29, 0x58, 0x79, 0x96, 0x9f, 0x1a, 0xff, 0xdc, 0xef, 0x4c, 0xb3, 0x1b, 0x79, 0x36, 0xd3, 0x03, 0x4d, 0x08, 0x15, 0x54, 0xa7, 0x84, 0x2d, 0xc3, 0xb2, 0x44, 0x75, 0x15, 0x9f, 0x57, 0xae, 0x25, 0x64, 0xcc, 0x5f, 0xdf, 0x7d, 0xd3, 0xe9, 0xb7, 0xbc, 0xeb, 0x01, 0x92, 0xda, 0x9f, 0x7e, 0xc3, 0xc6, 0xce, 0xd9, 0xc2, 0x16, 0x5a, 0x52, 0x0c, 0x1e, 0xe2, 0x92, 0x4a, 0xf2, 0x33, 0x13, 0x78, 0x5f, 0xa3, 0xa8, 0x0d, 0x99, 0x75, 0x8d, 0x33, 0xd5, 0x71, 0xc6, 0x3c, 0x86, 0xf9, 0x36, 0xbf, 0x86, 0x2e, 0xc3, 0xfe, 0x63, 0x7d, 0x50, 0x94, 0xb6, 0x71, 0x7f, 0x9f, 0xb6, 0x55, 0xa5, 0x02, 0x81, 0x81, 0x00, 0xd0, 0xa6, 0xcd, 0xaf, 0x92, 0x3b, 0x7a, 0x2f, 0x17, 0xfd, 0xd1, 0x05, 0x6b, 0x9c, 0x95, 0xb7, 0x7b, 0x39, 0x0c, 0xa5, 0xde, 0xb1, 0xa4, 0x86, 0x87, 0x39, 0x73, 0xb0, 0x22, 0xb3, 0x7c, 0x6a, 0x14, 0xdc, 0x19, 0x98, 0xa7, 0xe7, 0x02, 0xdb, 0x54, 0xa0, 0xc3, 0xbc, 0x80, 0x54, 0x60, 0xb6, 0xa6, 0xf4, 0xc5, 0x01, 0xe1, 0xc3, 0xf7, 0xc3, 0xd2, 0xdb, 0xe7, 0x1f, 0xc9, 0xcc, 0x51, 0x66, 0x66, 0xd0, 0xce, 0x31, 0x5a, 0x31, 0x76, 0xb7, 0x98, 0x52, 0xda, 0x82, 0xe8, 0x33, 0xc8, 0xf0, 0x1a, 0x8f, 0x95, 0x46, 0x7f, 0x48, 0x72, 0x47, 0x1e, 0x33, 0x3c, 0x0f, 0xd7, 0x55, 0x21, 0xc3, 0xea, 0x10, 0x8e, 0xae, 0xbc, 0x18, 0xa5, 0xcc, 0x85, 0xf1, 0x09, 0x3d, 0x15, 0x82, 0xa0, 0x49, 0x55, 0xd6, 0x7f, 0x64, 0xe0, 0xb0, 0xf0, 0x17, 0x75, 0xbd, 0x92, 0xc7, 0x83, 0xe3, 0x59, 0x09, 0x02, 0x81, 0x81, 0x00, 0x88, 0x6b, 0xd4, 0x2b, 0x87, 0xcc, 0xee, 0x93, 0xe7, 0x9d, 0x2a, 0xae, 0x01, 0x56, 0x1d, 0x8b, 0xa8, 0x3a, 0x1d, 0x7b, 0xae, 0xfa, 0x3c, 0x88, 0xff, 0x56, 0xf2, 0xd9, 0xc6, 0x91, 0x94, 0x4f, 0x04, 0xd2, 0x5b, 0x1e, 0x61, 0x4f, 0x7e, 0x96, 0xcb, 0xdb, 0xa3, 0x3c, 0x33, 0xf5, 0x37, 0x52, 0x35, 0x54, 0x18, 0x51, 0xd0, 0x5d, 0xa3, 0x96, 0xe3, 0x66, 0x80, 0xc3, 0x93, 0xd9, 0xe2, 0x9d, 0x9b, 0x23, 0x5a, 0xbb, 0x33, 0x16, 0xe0, 0x77, 0xd4, 0x0f, 0x32, 0x3b, 0xa8, 0xe4, 0xe5, 0xa9, 0x7a, 0x7c, 0xf3, 0xcf, 0x24, 0xf8, 0xcf, 0x15, 0xda, 0x2e, 0xdc, 0x24, 0x5d, 0x33, 0x5b, 0x06, 0xa5, 0x7e, 0x81, 0x41, 0x46, 0x3f, 0x55, 0x6c, 0x5f, 0x1e, 0x53, 0x62, 0x9b, 0x25, 0x8d, 0xbb, 0x2e, 0x45, 0x2a, 0xf2, 0x0c, 0x10, 0x2a, 0x6a, 0x69, 0xd0, 0x09, 0xf4, 0x81, 0x1b, 0x71, 0x55, 0x02, 0x81, 0x80, 0x66, 0x63, 0x74, 0x4b, 0xd3, 0xd6, 0x9b, 0xfe, 0xc0, 0x27, 0x2d, 0x8b, 0x1b, 0x63, 0x9b, 0x94, 0x8e, 0x43, 0x50, 0x91, 0x94, 0xd6, 0x57, 0x86, 0x2c, 0x95, 0x64, 0xcf, 0xea, 0x37, 0x69, 0xb6, 0x24, 0xc6, 0x5d, 0x49, 0x2c, 0x1b, 0x90, 0xab, 0x50, 0xbc, 0x13, 0x51, 0x4d, 0x28, 0x1a, 0xcd, 0x86, 0xe0, 0x56, 0x4c, 0xb6, 0x1d, 0x14, 0x58, 0x64, 0x00, 0xc5, 0x4a, 0x34, 0x1c, 0xaf, 0x55, 0x30, 0xdf, 0x06, 0x4f, 0xf1, 0x92, 0x94, 0x4f, 0x43, 0xd0, 0x64, 0xaa, 0x18, 0x88, 0x50, 0xf2, 0x82, 0x16, 0x33, 0x8a, 0x84, 0xab, 0x68, 0x68, 0xbd, 0xc9, 0x26, 0x90, 0x1f, 0x7b, 0x07, 0x36, 0xbc, 0x85, 0xa3, 0x7e, 0xdb, 0x8e, 0xbc, 0xcd, 0xc0, 0x6c, 0xa7, 0xbb, 0xf1, 0xf2, 0x47, 0xf5, 0xb4, 0xc9, 0xad, 0x7a, 0x33, 0x48, 0xa0, 0x88, 0xe2, 0x9e, 0x44, 0x88, 0xe3, 0x8f, 0x8d, 0x01, 0x02, 0x81, 0x80, 0x04, 0xa3, 0xe0, 0xb3, 0x7e, 0xdd, 0x12, 0x94, 0x27, 0xb0, 0xac, 0x4b, 0x26, 0xfd, 0xb2, 0x5f, 0x2b, 0x91, 0x29, 0x5a, 0x0b, 0x2b, 0x9a, 0xeb, 0x08, 0x21, 0xde, 0x15, 0x79, 0x8a, 0x55, 0x0c, 0xec, 0xac, 0x85, 0x72, 0x11, 0xb6, 0x1d, 0x51, 0xf1, 0xa6, 0x28, 0xa0, 0x86, 0xae, 0x23, 0x7c, 0x4c, 0x2c, 0xfe, 0xce, 0xd4, 0xd3, 0xf2, 0x67, 0x47, 0x6c, 0xa7, 0xfd, 0xe6, 0x80, 0x4f, 0x8d, 0x54, 0xa9, 0x8a, 0xb8, 0x80, 0xc5, 0xbc, 0x6b, 0x7e, 0xe1, 0xc2, 0xa1, 0x24, 0xcf, 0x2d, 0xe1, 0x0c, 0x9f, 0x7b, 0x71, 0xcf, 0x75, 0xb2, 0x04, 0xf8, 0x51, 0xac, 0x07, 0x10, 0x56, 0x93, 0x46, 0x92, 0xdd, 0x1d, 0x5b, 0x1f, 0x94, 0x87, 0xcf, 0xe2, 0x99, 0x36, 0x89, 0xe7, 0xc2, 0x8a, 0x0a, 0x9e, 0x0d, 0x30, 0x17, 0xd5, 0x6d, 0xde, 0x10, 0x94, 0x47, 0x35, 0x89, 0x10, 0xe6, 0x8c, 0x0e};
u8_t cert[] = {0x30, 0x82, 0x03, 0x6b, 0x30, 0x82, 0x02, 0x53, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x72, 0x8e, 0xfd, 0x0e, 0x52, 0x0a, 0x87, 0xdd, 0x55, 0x25, 0xee, 0x05, 0x11, 0x1d, 0x0d, 0xf7, 0xc8, 0x64, 0x5b, 0xa0, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x08, 0x49, 0x4f, 0x20, 0x50, 0x72, 0x65, 0x73, 0x73, 0x31, 0x0e, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x05, 0x50, 0x69, 0x63, 0x6f, 0x57, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x33, 0x30, 0x32, 0x30, 0x36, 0x31, 0x35, 0x30, 0x39, 0x35, 0x34, 0x5a, 0x17, 0x0d, 0x32, 0x34, 0x30, 0x32, 0x30, 0x36, 0x31, 0x35, 0x30, 0x39, 0x35, 0x34, 0x5a, 0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x08, 0x49, 0x4f, 0x20, 0x50, 0x72, 0x65, 0x73, 0x73, 0x31, 0x0e, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x05, 0x50, 0x69, 0x63, 0x6f, 0x57, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xbd, 0xb3, 0xb6, 0x94, 0x9f, 0x87, 0x85, 0xd6, 0xd4, 0xd0, 0xf9, 0x24, 0x4b, 0x8c, 0x7d, 0x9e, 0xf5, 0x83, 0xac, 0x90, 0x37, 0x5b, 0xdf, 0x4d, 0x9b, 0x05, 0x6b, 0x5f, 0xaa, 0x87, 0x31, 0x87, 0x0e, 0x97, 0x90, 0xa0, 0xff, 0x12, 0x81, 0xcc, 0xfe, 0x66, 0xa3, 0x8e, 0x34, 0x33, 0x63, 0x27, 0x10, 0xa4, 0xf1, 0x57, 0x27, 0x72, 0x54, 0x45, 0x41, 0x62, 0xee, 0x00, 0x36, 0xaa, 0x1f, 0xfa, 0xa3, 0xb0, 0x27, 0xeb, 0x3e, 0xf3, 0xcf, 0x04, 0x17, 0x68, 0x22, 0xf1, 0x1e, 0x1c, 0x9e, 0x27, 0x7d, 0x82, 0xb3, 0x3f, 0x3c, 0x12, 0x63, 0x94, 0x3b, 0xae, 0x87, 0x3c, 0x33, 0x6a, 0x08, 0x63, 0x84, 0xc2, 0xf8, 0x87, 0xbd, 0xfd, 0x25, 0x92, 0xb7, 0x8d, 0xdb, 0xac, 0xe9, 0xcb, 0x3f, 0x04, 0x3d, 0xee, 0x9f, 0xf6, 0x17, 0xbe, 0xea, 0x41, 0x7f, 0x2b, 0x2d, 0x4a, 0xbf, 0x64, 0xea, 0x01, 0x83, 0xf2, 0x59, 0x82, 0x6c, 0xcb, 0x6c, 0x1f, 0x91, 0x53, 0xde, 0x8a, 0x36, 0x7f, 0x41, 0x7e, 0x19, 0x02, 0x80, 0x42, 0x8c, 0xd5, 0xc1, 0x3c, 0x22, 0x06, 0xf4, 0x2d, 0x09, 0x45, 0xbf, 0xc1, 0x12, 0xe3, 0xfc, 0xa3, 0xc2, 0x89, 0x11, 0x7f, 0x01, 0xcb, 0x49, 0xab, 0xc1, 0x50, 0x37, 0xca, 0x03, 0xb7, 0x44, 0x94, 0x16, 0xbf, 0xd6, 0xf5, 0xa6, 0xbc, 0x10, 0x86, 0xf2, 0x97, 0xea, 0x66, 0x15, 0xa3, 0x9f, 0x4d, 0xf0, 0xe6, 0xa5, 0xfb, 0x1f, 0x25, 0xd7, 0x71, 0xed, 0x85, 0x53, 0x5b, 0x86, 0x1c, 0x46, 0x29, 0xb5, 0xa8, 0xa8, 0x25, 0x27, 0x5a, 0x51, 0x27, 0x30, 0xa7, 0x94, 0x07, 0x21, 0xf7, 0x66, 0xe2, 0xab, 0x16, 0x0e, 0x59, 0xa2, 0x7a, 0x70, 0x30, 0xba, 0x6b, 0x9f, 0xf9, 0x4d, 0x22, 0x4e, 0xa3, 0x33, 0x7e, 0x49, 0x43, 0x62, 0x29, 0xf5, 0xc7, 0x61, 0x7e, 0x5f, 0xcd, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x53, 0x30, 0x51, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x93, 0xc8, 0x8f, 0xac, 0x37, 0x01, 0x7e, 0x4d, 0xd2, 0x87, 0x7a, 0xb5, 0x26, 0xba, 0xd1, 0xa6, 0x1a, 0xcd, 0xd1, 0xb2, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x93, 0xc8, 0x8f, 0xac, 0x37, 0x01, 0x7e, 0x4d, 0xd2, 0x87, 0x7a, 0xb5, 0x26, 0xba, 0xd1, 0xa6, 0x1a, 0xcd, 0xd1, 0xb2, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x5b, 0x91, 0x51, 0xe1, 0x89, 0x20, 0xf5, 0xdf, 0x02, 0x94, 0x59, 0x76, 0x9e, 0xdc, 0x53, 0xf3, 0x17, 0x8f, 0x96, 0x17, 0xd1, 0x2f, 0x65, 0x36, 0xd4, 0x56, 0x7e, 0xd8, 0x0d, 0x7e, 0x59, 0x79, 0xab, 0x47, 0x67, 0x01, 0xb6, 0x9e, 0xf6, 0x7a, 0x0d, 0x20, 0xd2, 0xb2, 0x2d, 0x87, 0x84, 0x07, 0x40, 0x2d, 0x83, 0x1e, 0x16, 0x4f, 0x2d, 0x20, 0xaf, 0xf2, 0xca, 0xde, 0x10, 0x73, 0x41, 0xb9, 0x48, 0x3c, 0x4f, 0x9d, 0x55, 0xbc, 0xee, 0x68, 0xae, 0x66, 0x4d, 0x5d, 0x41, 0xa9, 0xbc, 0x51, 0x6d, 0xe2, 0x37, 0x0c, 0x0f, 0xf4, 0x43, 0xa0, 0x84, 0xf9, 0x40, 0xbc, 0x89, 0xaa, 0xcd, 0x14, 0xb4, 0xd5, 0xda, 0xd1, 0xb3, 0x2c, 0x4a, 0x56, 0x7e, 0x86, 0x2c, 0x71, 0xaa, 0x75, 0x86, 0x48, 0x14, 0x2a, 0xbc, 0x05, 0xab, 0x14, 0x72, 0x72, 0x01, 0xc8, 0xff, 0x02, 0x3d, 0x2e, 0xe9, 0xef, 0x21, 0x4d, 0x71, 0xf3, 0x0c, 0xba, 0x40, 0xfd, 0x9f, 0xb1, 0x40, 0xea, 0x47, 0x65, 0x3d, 0xb7, 0x52, 0xd8, 0xbb, 0x13, 0x30, 0x38, 0xb4, 0x3c, 0xbf, 0x76, 0x06, 0xe2, 0xb3, 0x3f, 0xf7, 0x7b, 0xdd, 0xdf, 0x54, 0x7b, 0x8d, 0x0c, 0x4d, 0x4a, 0x96, 0xcd, 0x14, 0x5c, 0x7d, 0xed, 0xb3, 0x2f, 0xbd, 0x27, 0xc8, 0x52, 0x6e, 0x58, 0x8e, 0x9c, 0x07, 0xa1, 0x52, 0xe2, 0x49, 0x8c, 0x04, 0x3f, 0x84, 0x32, 0x7b, 0xff, 0x5f, 0xf4, 0xf2, 0xdf, 0x3c, 0x73, 0xff, 0x9f, 0x63, 0x0e, 0xe5, 0x7f, 0xdf, 0xa8, 0x7e, 0x4d, 0xf3, 0x29, 0xd8, 0x2b, 0x41, 0x25, 0xbc, 0x73, 0x41, 0x3b, 0x1f, 0x39, 0x64, 0x48, 0x85, 0xe5, 0x66, 0x90, 0x8c, 0xd3, 0x8a, 0xce, 0xdc, 0xb5, 0x0d, 0x93, 0xb0, 0xd0, 0x8a, 0xef, 0x74, 0x8f, 0x28, 0x2f, 0x2c, 0x96, 0x4a, 0x4f, 0xc3, 0xf1, 0xde, 0x25, 0xff, 0xd4};
struct altcp_tls_config *tls_config = altcp_tls_create_config_server_privkey_cert(key, sizeof(key), NULL, 0, cert, sizeof(cert));
struct altcp_pcb *pcb = altcp_tls_new(tls_config, IPADDR_TYPE_ANY);
altcp_accept(pcb, accept);
altcp_bind(pcb, IP_ADDR_ANY, 443);
cyw43_arch_lwip_begin();
pcb = altcp_listen_with_backlog(pcb, 3);
cyw43_arch_lwip_end();
while (true)
{
sleep_ms(500);
}
}
Page 137 Full listing not in book
Simple HTTPS Server lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#define LWIP_ALTCP 1
#define LWIP_ALTCP_TLS 1
#define LWIP_ALTCP_TLS_MBEDTLS 1
#define LWIP_DEBUG 1
#define ALTCP_MBEDTLS_DEBUG LWIP_DBG_ON
#define TCP_LISTEN_BACKLOG 1
#endif /* __LWIPOPTS_H__ */
Page 137 Full listing not in book
Simple HTTPS Server mbedtls_config.h
//Hardware config
#define MBEDTLS_NO_PLATFORM_ENTROPY
#define MBEDTLS_ENTROPY_HARDWARE_ALT
#define MBEDTLS_HAVE_TIME
//error reporting
#define MBEDTLS_ERROR_C
//used by LwIP
#define MBEDTLS_ENTROPY_C
#define MBEDTLS_CTR_DRBG_C
//RSA KEY EXCHANGE
#define MBEDTLS_KEY_EXCHANGE_RSA_ENABLED
#define MBEDTLS_RSA_C
//general key exchange
#define MBEDTLS_PKCS1_V15
#define MBEDTLS_BIGNUM_C
#define MBEDTLS_PK_C
#define MBEDTLS_PK_PARSE_C
//encryption
#define MBEDTLS_AES_C
#define MBEDTLS_CCM_C
#define MBEDTLS_CIPHER_MODE_CBC
#define MBEDTLS_AES_FEWER_TABLES
#define MBEDTLS_GCM_C
//certs
#define MBEDTLS_X509_CRT_PARSE_C
#define MBEDTLS_X509_USE_C
#define MBEDTLS_OID_C
#define MBEDTLS_ASN1_PARSE_C
#define MBEDTLS_ASN1_WRITE_C
//hash methods
#define MBEDTLS_SHA1_C
#define MBEDTLS_SHA224_C
#define MBEDTLS_SHA256_C
#define MBEDTLS_SHA512_C
//TLS
#define MBEDTLS_CIPHER_C
#define MBEDTLS_SSL_TLS_C
#define MBEDTLS_MD_C
//enable client and server modes and TLS
#define MBEDTLS_SSL_CLI_C
#define MBEDTLS_SSL_SERVER_NAME_INDICATION
#define MBEDTLS_SSL_SRV_C
//enable TLS 1.2
#define MBEDTLS_SSL_PROTO_TLS1_2
#include "/home/pi/pico/pico-sdk/lib/mbedtls/include/mbedtls/check_config.h"
Page 137 Full listing not in book
Simple HTTPS Server CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background hardware_rtc pico_lwip_mbedtls pico_mbedtls)
pico_add_extra_outputs(main)
Page 140 Simple HTTP Bultin Server Main Program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/apps/httpd.h"
#include "setupWifi.h"
int main()
{
stdio_init_all();
connect();
httpd_init();
while (true)
{
sleep_ms(500);
}
}
Page 140 Full listing not in book
Simple HTTP Bultin Server Cmakelists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background pico_lwip_http)
pico_add_extra_outputs(main)
Page 140 Full listing not in book
Simple HTTP Bultin Server lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#define LWIP_ALTCP 1
#define LWIP_DEBUG 1
#define TCP_LISTEN_BACKLOG 1
#endif /* __LWIPOPTS_H__ */
Page 141 Linux Cmakelists.txt for htmlgen
cmake_minimum_required(VERSION 3.13)
project(makefsdata C CXX ASM)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
add_executable(htmlgen
makefsdata.c
)
target_include_directories(htmlgen
PRIVATE ../../../../src/include/
PRIVATE ../../../../contrib/ports/unix/port/include/
PRIVATE ${CMAKE_CURRENT_LIST_DIR})
Page 141 Windows Cmakelists.txt for htmlgen
cmake_minimum_required(VERSION 3.13)
project(makefsdata C CXX ASM)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
add_executable(htmlgen
makefsdata.c
)
target_include_directories(htmlgen
PRIVATE ../../../../src/include/
PRIVATE ../../../../contrib/ports/win32/include/
PRIVATE ${CMAKE_CURRENT_LIST_DIR})Page 151
Simple HTTPS Bultin Server Main Program TLS and SSI
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/altcp_tls.h"
#include "lwip/apps/httpd.h"
#include "hardware/structs/rosc.h"
#include "hardware/rtc.h"
#include "time.h"
#include "setupWifi.h"
#define BUF_SIZE 2048
void getDateNow(struct tm *t)
{
datetime_t rtc;
rtc_get_datetime(&rtc);
t->tm_sec = rtc.sec;
t->tm_min = rtc.min;
t->tm_hour = rtc.hour;
t->tm_mday = rtc.day;
t->tm_mon = rtc.month - 1;
t->tm_year = rtc.year - 1900;
t->tm_wday = rtc.dotw;
t->tm_yday = 0;
t->tm_isdst = -1;
}
void setRTC()
{
datetime_t t = {
.year = 2023,
.month = 02,
.day = 05,
.dotw = 0,
.hour = 6,
.min = 14,
.sec = 00};
rtc_init();
rtc_set_datetime(&t);
}
const char *ssitags[] = {"temp", "hum"};
u16_t mySSIHandler(int iIndex, char *pcInsert, int iInsertLen)
{
switch(iIndex){
case 0:
snprintf(pcInsert, iInsertLen, "42 C");
break;
case 1:
snprintf(pcInsert, iInsertLen, "80%%");
break;
}
}
int main()
{
stdio_init_all();
setRTC();
connect();
u8_t key[] = {0x30, 0x82, 0x04, 0xbd, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, 0x04, 0xa7, 0x30, 0x82, 0x04, 0xa3, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00, 0xbd, 0xb3, 0xb6, 0x94, 0x9f, 0x87, 0x85, 0xd6, 0xd4, 0xd0, 0xf9, 0x24, 0x4b, 0x8c, 0x7d, 0x9e, 0xf5, 0x83, 0xac, 0x90, 0x37, 0x5b, 0xdf, 0x4d, 0x9b, 0x05, 0x6b, 0x5f, 0xaa, 0x87, 0x31, 0x87, 0x0e, 0x97, 0x90, 0xa0, 0xff, 0x12, 0x81, 0xcc, 0xfe, 0x66, 0xa3, 0x8e, 0x34, 0x33, 0x63, 0x27, 0x10, 0xa4, 0xf1, 0x57, 0x27, 0x72, 0x54, 0x45, 0x41, 0x62, 0xee, 0x00, 0x36, 0xaa, 0x1f, 0xfa, 0xa3, 0xb0, 0x27, 0xeb, 0x3e, 0xf3, 0xcf, 0x04, 0x17, 0x68, 0x22, 0xf1, 0x1e, 0x1c, 0x9e, 0x27, 0x7d, 0x82, 0xb3, 0x3f, 0x3c, 0x12, 0x63, 0x94, 0x3b, 0xae, 0x87, 0x3c, 0x33, 0x6a, 0x08, 0x63, 0x84, 0xc2, 0xf8, 0x87, 0xbd, 0xfd, 0x25, 0x92, 0xb7, 0x8d, 0xdb, 0xac, 0xe9, 0xcb, 0x3f, 0x04, 0x3d, 0xee, 0x9f, 0xf6, 0x17, 0xbe, 0xea, 0x41, 0x7f, 0x2b, 0x2d, 0x4a, 0xbf, 0x64, 0xea, 0x01, 0x83, 0xf2, 0x59, 0x82, 0x6c, 0xcb, 0x6c, 0x1f, 0x91, 0x53, 0xde, 0x8a, 0x36, 0x7f, 0x41, 0x7e, 0x19, 0x02, 0x80, 0x42, 0x8c, 0xd5, 0xc1, 0x3c, 0x22, 0x06, 0xf4, 0x2d, 0x09, 0x45, 0xbf, 0xc1, 0x12, 0xe3, 0xfc, 0xa3, 0xc2, 0x89, 0x11, 0x7f, 0x01, 0xcb, 0x49, 0xab, 0xc1, 0x50, 0x37, 0xca, 0x03, 0xb7, 0x44, 0x94, 0x16, 0xbf, 0xd6, 0xf5, 0xa6, 0xbc, 0x10, 0x86, 0xf2, 0x97, 0xea, 0x66, 0x15, 0xa3, 0x9f, 0x4d, 0xf0, 0xe6, 0xa5, 0xfb, 0x1f, 0x25, 0xd7, 0x71, 0xed, 0x85, 0x53, 0x5b, 0x86, 0x1c, 0x46, 0x29, 0xb5, 0xa8, 0xa8, 0x25, 0x27, 0x5a, 0x51, 0x27, 0x30, 0xa7, 0x94, 0x07, 0x21, 0xf7, 0x66, 0xe2, 0xab, 0x16, 0x0e, 0x59, 0xa2, 0x7a, 0x70, 0x30, 0xba, 0x6b, 0x9f, 0xf9, 0x4d, 0x22, 0x4e, 0xa3, 0x33, 0x7e, 0x49, 0x43, 0x62, 0x29, 0xf5, 0xc7, 0x61, 0x7e, 0x5f, 0xcd, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01, 0x00, 0x1e, 0x04, 0x4b, 0xc5, 0xa4, 0xa0, 0x8b, 0x1a, 0xfd, 0x3d, 0xbb, 0xce, 0x74, 0x6d, 0xdc, 0x8a, 0xc4, 0x8a, 0x7b, 0x49, 0xae, 0x98, 0xc8, 0xf2, 0xbc, 0xae, 0xd4, 0xd8, 0xa4, 0x61, 0x14, 0x03, 0x2c, 0xd9, 0xea, 0xb6, 0xae, 0xe5, 0xbc, 0xc8, 0x35, 0x11, 0x04, 0x9c, 0x41, 0xc2, 0x47, 0xd4, 0x2c, 0x9c, 0x0c, 0xdc, 0x1f, 0x8f, 0xc5, 0xa9, 0xd7, 0xb8, 0xd1, 0xb4, 0x12, 0xf2, 0x44, 0x71, 0x22, 0x69, 0x83, 0x47, 0x84, 0x04, 0x8c, 0x23, 0x37, 0x98, 0xf0, 0xbe, 0x7a, 0x67, 0x48, 0xd7, 0x32, 0xd2, 0xf5, 0x8d, 0xf1, 0xf1, 0x6e, 0xf4, 0x4b, 0xa5, 0x48, 0x1c, 0xcc, 0x7d, 0xe0, 0xa9, 0xee, 0x9d, 0xf3, 0x39, 0x77, 0x64, 0x91, 0x07, 0x70, 0x27, 0xf0, 0x34, 0xa2, 0x21, 0xd8, 0xec, 0xd0, 0xe7, 0xeb, 0x43, 0xc3, 0x6a, 0x20, 0x23, 0x10, 0xfe, 0x42, 0x02, 0x6b, 0xda, 0x89, 0xf4, 0x41, 0x96, 0x64, 0x32, 0x52, 0x20, 0x05, 0x0d, 0x5b, 0xf3, 0x67, 0x51, 0xb7, 0x7d, 0xd1, 0x24, 0x0b, 0x2c, 0x33, 0x84, 0x5b, 0xf9, 0xed, 0x66, 0xe6, 0x3c, 0x4d, 0xdf, 0x09, 0x3e, 0xd5, 0xe5, 0x1c, 0x27, 0x2c, 0x81, 0xee, 0x03, 0x91, 0x8d, 0xc0, 0x2b, 0x3e, 0xd9, 0x37, 0x8e, 0x3d, 0xd1, 0x30, 0xd6, 0x97, 0x7b, 0x98, 0xfb, 0x80, 0x13, 0x5a, 0x84, 0x08, 0x90, 0x0d, 0x5c, 0x99, 0x51, 0x4f, 0x8f, 0xab, 0x0c, 0x39, 0x69, 0x76, 0xf8, 0xf4, 0xfd, 0xa7, 0x04, 0x8d, 0x72, 0x27, 0xa6, 0x1e, 0xbd, 0xff, 0x10, 0x43, 0xe8, 0x53, 0xe7, 0x08, 0xb8, 0xbd, 0x55, 0xb4, 0x7a, 0xa2, 0x44, 0xe9, 0xe7, 0x78, 0xf7, 0x11, 0x49, 0x01, 0x70, 0x60, 0xdf, 0xe8, 0xd1, 0xb0, 0x8c, 0xa2, 0x3d, 0x98, 0x07, 0x9b, 0x66, 0xff, 0xe8, 0x68, 0x33, 0x82, 0xe3, 0x75, 0x3d, 0x37, 0x8d, 0xf2, 0x41, 0x02, 0x81, 0x81, 0x00, 0xe8, 0xc0, 0x12, 0x7f, 0x02, 0x98, 0x75, 0x23, 0xa6, 0x32, 0x92, 0x4e, 0x11, 0x27, 0xad, 0xda, 0x5b, 0x9e, 0xec, 0x9c, 0xa4, 0xb4, 0x26, 0x2b, 0x2b, 0xd4, 0xdb, 0x1a, 0x9e, 0xd5, 0xd3, 0xa8, 0xb4, 0x29, 0x58, 0x79, 0x96, 0x9f, 0x1a, 0xff, 0xdc, 0xef, 0x4c, 0xb3, 0x1b, 0x79, 0x36, 0xd3, 0x03, 0x4d, 0x08, 0x15, 0x54, 0xa7, 0x84, 0x2d, 0xc3, 0xb2, 0x44, 0x75, 0x15, 0x9f, 0x57, 0xae, 0x25, 0x64, 0xcc, 0x5f, 0xdf, 0x7d, 0xd3, 0xe9, 0xb7, 0xbc, 0xeb, 0x01, 0x92, 0xda, 0x9f, 0x7e, 0xc3, 0xc6, 0xce, 0xd9, 0xc2, 0x16, 0x5a, 0x52, 0x0c, 0x1e, 0xe2, 0x92, 0x4a, 0xf2, 0x33, 0x13, 0x78, 0x5f, 0xa3, 0xa8, 0x0d, 0x99, 0x75, 0x8d, 0x33, 0xd5, 0x71, 0xc6, 0x3c, 0x86, 0xf9, 0x36, 0xbf, 0x86, 0x2e, 0xc3, 0xfe, 0x63, 0x7d, 0x50, 0x94, 0xb6, 0x71, 0x7f, 0x9f, 0xb6, 0x55, 0xa5, 0x02, 0x81, 0x81, 0x00, 0xd0, 0xa6, 0xcd, 0xaf, 0x92, 0x3b, 0x7a, 0x2f, 0x17, 0xfd, 0xd1, 0x05, 0x6b, 0x9c, 0x95, 0xb7, 0x7b, 0x39, 0x0c, 0xa5, 0xde, 0xb1, 0xa4, 0x86, 0x87, 0x39, 0x73, 0xb0, 0x22, 0xb3, 0x7c, 0x6a, 0x14, 0xdc, 0x19, 0x98, 0xa7, 0xe7, 0x02, 0xdb, 0x54, 0xa0, 0xc3, 0xbc, 0x80, 0x54, 0x60, 0xb6, 0xa6, 0xf4, 0xc5, 0x01, 0xe1, 0xc3, 0xf7, 0xc3, 0xd2, 0xdb, 0xe7, 0x1f, 0xc9, 0xcc, 0x51, 0x66, 0x66, 0xd0, 0xce, 0x31, 0x5a, 0x31, 0x76, 0xb7, 0x98, 0x52, 0xda, 0x82, 0xe8, 0x33, 0xc8, 0xf0, 0x1a, 0x8f, 0x95, 0x46, 0x7f, 0x48, 0x72, 0x47, 0x1e, 0x33, 0x3c, 0x0f, 0xd7, 0x55, 0x21, 0xc3, 0xea, 0x10, 0x8e, 0xae, 0xbc, 0x18, 0xa5, 0xcc, 0x85, 0xf1, 0x09, 0x3d, 0x15, 0x82, 0xa0, 0x49, 0x55, 0xd6, 0x7f, 0x64, 0xe0, 0xb0, 0xf0, 0x17, 0x75, 0xbd, 0x92, 0xc7, 0x83, 0xe3, 0x59, 0x09, 0x02, 0x81, 0x81, 0x00, 0x88, 0x6b, 0xd4, 0x2b, 0x87, 0xcc, 0xee, 0x93, 0xe7, 0x9d, 0x2a, 0xae, 0x01, 0x56, 0x1d, 0x8b, 0xa8, 0x3a, 0x1d, 0x7b, 0xae, 0xfa, 0x3c, 0x88, 0xff, 0x56, 0xf2, 0xd9, 0xc6, 0x91, 0x94, 0x4f, 0x04, 0xd2, 0x5b, 0x1e, 0x61, 0x4f, 0x7e, 0x96, 0xcb, 0xdb, 0xa3, 0x3c, 0x33, 0xf5, 0x37, 0x52, 0x35, 0x54, 0x18, 0x51, 0xd0, 0x5d, 0xa3, 0x96, 0xe3, 0x66, 0x80, 0xc3, 0x93, 0xd9, 0xe2, 0x9d, 0x9b, 0x23, 0x5a, 0xbb, 0x33, 0x16, 0xe0, 0x77, 0xd4, 0x0f, 0x32, 0x3b, 0xa8, 0xe4, 0xe5, 0xa9, 0x7a, 0x7c, 0xf3, 0xcf, 0x24, 0xf8, 0xcf, 0x15, 0xda, 0x2e, 0xdc, 0x24, 0x5d, 0x33, 0x5b, 0x06, 0xa5, 0x7e, 0x81, 0x41, 0x46, 0x3f, 0x55, 0x6c, 0x5f, 0x1e, 0x53, 0x62, 0x9b, 0x25, 0x8d, 0xbb, 0x2e, 0x45, 0x2a, 0xf2, 0x0c, 0x10, 0x2a, 0x6a, 0x69, 0xd0, 0x09, 0xf4, 0x81, 0x1b, 0x71, 0x55, 0x02, 0x81, 0x80, 0x66, 0x63, 0x74, 0x4b, 0xd3, 0xd6, 0x9b, 0xfe, 0xc0, 0x27, 0x2d, 0x8b, 0x1b, 0x63, 0x9b, 0x94, 0x8e, 0x43, 0x50, 0x91, 0x94, 0xd6, 0x57, 0x86, 0x2c, 0x95, 0x64, 0xcf, 0xea, 0x37, 0x69, 0xb6, 0x24, 0xc6, 0x5d, 0x49, 0x2c, 0x1b, 0x90, 0xab, 0x50, 0xbc, 0x13, 0x51, 0x4d, 0x28, 0x1a, 0xcd, 0x86, 0xe0, 0x56, 0x4c, 0xb6, 0x1d, 0x14, 0x58, 0x64, 0x00, 0xc5, 0x4a, 0x34, 0x1c, 0xaf, 0x55, 0x30, 0xdf, 0x06, 0x4f, 0xf1, 0x92, 0x94, 0x4f, 0x43, 0xd0, 0x64, 0xaa, 0x18, 0x88, 0x50, 0xf2, 0x82, 0x16, 0x33, 0x8a, 0x84, 0xab, 0x68, 0x68, 0xbd, 0xc9, 0x26, 0x90, 0x1f, 0x7b, 0x07, 0x36, 0xbc, 0x85, 0xa3, 0x7e, 0xdb, 0x8e, 0xbc, 0xcd, 0xc0, 0x6c, 0xa7, 0xbb, 0xf1, 0xf2, 0x47, 0xf5, 0xb4, 0xc9, 0xad, 0x7a, 0x33, 0x48, 0xa0, 0x88, 0xe2, 0x9e, 0x44, 0x88, 0xe3, 0x8f, 0x8d, 0x01, 0x02, 0x81, 0x80, 0x04, 0xa3, 0xe0, 0xb3, 0x7e, 0xdd, 0x12, 0x94, 0x27, 0xb0, 0xac, 0x4b, 0x26, 0xfd, 0xb2, 0x5f, 0x2b, 0x91, 0x29, 0x5a, 0x0b, 0x2b, 0x9a, 0xeb, 0x08, 0x21, 0xde, 0x15, 0x79, 0x8a, 0x55, 0x0c, 0xec, 0xac, 0x85, 0x72, 0x11, 0xb6, 0x1d, 0x51, 0xf1, 0xa6, 0x28, 0xa0, 0x86, 0xae, 0x23, 0x7c, 0x4c, 0x2c, 0xfe, 0xce, 0xd4, 0xd3, 0xf2, 0x67, 0x47, 0x6c, 0xa7, 0xfd, 0xe6, 0x80, 0x4f, 0x8d, 0x54, 0xa9, 0x8a, 0xb8, 0x80, 0xc5, 0xbc, 0x6b, 0x7e, 0xe1, 0xc2, 0xa1, 0x24, 0xcf, 0x2d, 0xe1, 0x0c, 0x9f, 0x7b, 0x71, 0xcf, 0x75, 0xb2, 0x04, 0xf8, 0x51, 0xac, 0x07, 0x10, 0x56, 0x93, 0x46, 0x92, 0xdd, 0x1d, 0x5b, 0x1f, 0x94, 0x87, 0xcf, 0xe2, 0x99, 0x36, 0x89, 0xe7, 0xc2, 0x8a, 0x0a, 0x9e, 0x0d, 0x30, 0x17, 0xd5, 0x6d, 0xde, 0x10, 0x94, 0x47, 0x35, 0x89, 0x10, 0xe6, 0x8c, 0x0e};
u8_t cert[] = {0x30, 0x82, 0x03, 0x6b, 0x30, 0x82, 0x02, 0x53, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x72, 0x8e, 0xfd, 0x0e, 0x52, 0x0a, 0x87, 0xdd, 0x55, 0x25, 0xee, 0x05, 0x11, 0x1d, 0x0d, 0xf7, 0xc8, 0x64, 0x5b, 0xa0, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x08, 0x49, 0x4f, 0x20, 0x50, 0x72, 0x65, 0x73, 0x73, 0x31, 0x0e, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x05, 0x50, 0x69, 0x63, 0x6f, 0x57, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x33, 0x30, 0x32, 0x30, 0x36, 0x31, 0x35, 0x30, 0x39, 0x35, 0x34, 0x5a, 0x17, 0x0d, 0x32, 0x34, 0x30, 0x32, 0x30, 0x36, 0x31, 0x35, 0x30, 0x39, 0x35, 0x34, 0x5a, 0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x08, 0x49, 0x4f, 0x20, 0x50, 0x72, 0x65, 0x73, 0x73, 0x31, 0x0e, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x05, 0x50, 0x69, 0x63, 0x6f, 0x57, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xbd, 0xb3, 0xb6, 0x94, 0x9f, 0x87, 0x85, 0xd6, 0xd4, 0xd0, 0xf9, 0x24, 0x4b, 0x8c, 0x7d, 0x9e, 0xf5, 0x83, 0xac, 0x90, 0x37, 0x5b, 0xdf, 0x4d, 0x9b, 0x05, 0x6b, 0x5f, 0xaa, 0x87, 0x31, 0x87, 0x0e, 0x97, 0x90, 0xa0, 0xff, 0x12, 0x81, 0xcc, 0xfe, 0x66, 0xa3, 0x8e, 0x34, 0x33, 0x63, 0x27, 0x10, 0xa4, 0xf1, 0x57, 0x27, 0x72, 0x54, 0x45, 0x41, 0x62, 0xee, 0x00, 0x36, 0xaa, 0x1f, 0xfa, 0xa3, 0xb0, 0x27, 0xeb, 0x3e, 0xf3, 0xcf, 0x04, 0x17, 0x68, 0x22, 0xf1, 0x1e, 0x1c, 0x9e, 0x27, 0x7d, 0x82, 0xb3, 0x3f, 0x3c, 0x12, 0x63, 0x94, 0x3b, 0xae, 0x87, 0x3c, 0x33, 0x6a, 0x08, 0x63, 0x84, 0xc2, 0xf8, 0x87, 0xbd, 0xfd, 0x25, 0x92, 0xb7, 0x8d, 0xdb, 0xac, 0xe9, 0xcb, 0x3f, 0x04, 0x3d, 0xee, 0x9f, 0xf6, 0x17, 0xbe, 0xea, 0x41, 0x7f, 0x2b, 0x2d, 0x4a, 0xbf, 0x64, 0xea, 0x01, 0x83, 0xf2, 0x59, 0x82, 0x6c, 0xcb, 0x6c, 0x1f, 0x91, 0x53, 0xde, 0x8a, 0x36, 0x7f, 0x41, 0x7e, 0x19, 0x02, 0x80, 0x42, 0x8c, 0xd5, 0xc1, 0x3c, 0x22, 0x06, 0xf4, 0x2d, 0x09, 0x45, 0xbf, 0xc1, 0x12, 0xe3, 0xfc, 0xa3, 0xc2, 0x89, 0x11, 0x7f, 0x01, 0xcb, 0x49, 0xab, 0xc1, 0x50, 0x37, 0xca, 0x03, 0xb7, 0x44, 0x94, 0x16, 0xbf, 0xd6, 0xf5, 0xa6, 0xbc, 0x10, 0x86, 0xf2, 0x97, 0xea, 0x66, 0x15, 0xa3, 0x9f, 0x4d, 0xf0, 0xe6, 0xa5, 0xfb, 0x1f, 0x25, 0xd7, 0x71, 0xed, 0x85, 0x53, 0x5b, 0x86, 0x1c, 0x46, 0x29, 0xb5, 0xa8, 0xa8, 0x25, 0x27, 0x5a, 0x51, 0x27, 0x30, 0xa7, 0x94, 0x07, 0x21, 0xf7, 0x66, 0xe2, 0xab, 0x16, 0x0e, 0x59, 0xa2, 0x7a, 0x70, 0x30, 0xba, 0x6b, 0x9f, 0xf9, 0x4d, 0x22, 0x4e, 0xa3, 0x33, 0x7e, 0x49, 0x43, 0x62, 0x29, 0xf5, 0xc7, 0x61, 0x7e, 0x5f, 0xcd, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x53, 0x30, 0x51, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x93, 0xc8, 0x8f, 0xac, 0x37, 0x01, 0x7e, 0x4d, 0xd2, 0x87, 0x7a, 0xb5, 0x26, 0xba, 0xd1, 0xa6, 0x1a, 0xcd, 0xd1, 0xb2, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x93, 0xc8, 0x8f, 0xac, 0x37, 0x01, 0x7e, 0x4d, 0xd2, 0x87, 0x7a, 0xb5, 0x26, 0xba, 0xd1, 0xa6, 0x1a, 0xcd, 0xd1, 0xb2, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x5b, 0x91, 0x51, 0xe1, 0x89, 0x20, 0xf5, 0xdf, 0x02, 0x94, 0x59, 0x76, 0x9e, 0xdc, 0x53, 0xf3, 0x17, 0x8f, 0x96, 0x17, 0xd1, 0x2f, 0x65, 0x36, 0xd4, 0x56, 0x7e, 0xd8, 0x0d, 0x7e, 0x59, 0x79, 0xab, 0x47, 0x67, 0x01, 0xb6, 0x9e, 0xf6, 0x7a, 0x0d, 0x20, 0xd2, 0xb2, 0x2d, 0x87, 0x84, 0x07, 0x40, 0x2d, 0x83, 0x1e, 0x16, 0x4f, 0x2d, 0x20, 0xaf, 0xf2, 0xca, 0xde, 0x10, 0x73, 0x41, 0xb9, 0x48, 0x3c, 0x4f, 0x9d, 0x55, 0xbc, 0xee, 0x68, 0xae, 0x66, 0x4d, 0x5d, 0x41, 0xa9, 0xbc, 0x51, 0x6d, 0xe2, 0x37, 0x0c, 0x0f, 0xf4, 0x43, 0xa0, 0x84, 0xf9, 0x40, 0xbc, 0x89, 0xaa, 0xcd, 0x14, 0xb4, 0xd5, 0xda, 0xd1, 0xb3, 0x2c, 0x4a, 0x56, 0x7e, 0x86, 0x2c, 0x71, 0xaa, 0x75, 0x86, 0x48, 0x14, 0x2a, 0xbc, 0x05, 0xab, 0x14, 0x72, 0x72, 0x01, 0xc8, 0xff, 0x02, 0x3d, 0x2e, 0xe9, 0xef, 0x21, 0x4d, 0x71, 0xf3, 0x0c, 0xba, 0x40, 0xfd, 0x9f, 0xb1, 0x40, 0xea, 0x47, 0x65, 0x3d, 0xb7, 0x52, 0xd8, 0xbb, 0x13, 0x30, 0x38, 0xb4, 0x3c, 0xbf, 0x76, 0x06, 0xe2, 0xb3, 0x3f, 0xf7, 0x7b, 0xdd, 0xdf, 0x54, 0x7b, 0x8d, 0x0c, 0x4d, 0x4a, 0x96, 0xcd, 0x14, 0x5c, 0x7d, 0xed, 0xb3, 0x2f, 0xbd, 0x27, 0xc8, 0x52, 0x6e, 0x58, 0x8e, 0x9c, 0x07, 0xa1, 0x52, 0xe2, 0x49, 0x8c, 0x04, 0x3f, 0x84, 0x32, 0x7b, 0xff, 0x5f, 0xf4, 0xf2, 0xdf, 0x3c, 0x73, 0xff, 0x9f, 0x63, 0x0e, 0xe5, 0x7f, 0xdf, 0xa8, 0x7e, 0x4d, 0xf3, 0x29, 0xd8, 0x2b, 0x41, 0x25, 0xbc, 0x73, 0x41, 0x3b, 0x1f, 0x39, 0x64, 0x48, 0x85, 0xe5, 0x66, 0x90, 0x8c, 0xd3, 0x8a, 0xce, 0xdc, 0xb5, 0x0d, 0x93, 0xb0, 0xd0, 0x8a, 0xef, 0x74, 0x8f, 0x28, 0x2f, 0x2c, 0x96, 0x4a, 0x4f, 0xc3, 0xf1, 0xde, 0x25, 0xff, 0xd4};
struct altcp_tls_config *tls_config = altcp_tls_create_config_server_privkey_cert(key, sizeof(key), NULL, 0, cert, sizeof(cert));
http_set_ssi_handler(mySSIHandler, ssitags, 2);
httpd_inits(tls_config);
while (true)
{
sleep_ms(500);
}
}
Page 151 Simple HTTPS Bultin Server TLS and SSI CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background hardware_rtc pico_lwip_mbedtls pico_mbedtls pico_lwip_http)
pico_add_extra_outputs(main)
Page 151 Full listing not in book
Simple HTTPS Bultin Server LWIPOPTS.H TLS and SSI
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#define LWIP_ALTCP 1
#define LWIP_ALTCP_TLS 1
#define LWIP_ALTCP_TLS_MBEDTLS 1
#define LWIP_DEBUG 1
#define ALTCP_MBEDTLS_DEBUG LWIP_DBG_ON
#define TCP_LISTEN_BACKLOG 1
#define HTTPD_ENABLE_HTTPS 1
#undef MEM_SIZE
#define MEM_SIZE 8000
#define LWIP_HTTPD_SSI 1
#endif /* __LWIPOPTS_H__ */
Page 144 Full listing not in book
Simple HTTPS Bultin Server mbedtls_config.h TLS and SSI
//Hardware config
#define MBEDTLS_NO_PLATFORM_ENTROPY
#define MBEDTLS_ENTROPY_HARDWARE_ALT
#define MBEDTLS_HAVE_TIME
//error reporting
#define MBEDTLS_ERROR_C
//used by LwIP
#define MBEDTLS_ENTROPY_C
#define MBEDTLS_CTR_DRBG_C
//RSA KEY EXCHANGE
#define MBEDTLS_KEY_EXCHANGE_RSA_ENABLED
#define MBEDTLS_RSA_C
//general key exchange
#define MBEDTLS_PKCS1_V15
#define MBEDTLS_BIGNUM_C
#define MBEDTLS_PK_C
#define MBEDTLS_PK_PARSE_C
//encryption
#define MBEDTLS_AES_C
#define MBEDTLS_CCM_C
#define MBEDTLS_CIPHER_MODE_CBC
#define MBEDTLS_AES_FEWER_TABLES
#define MBEDTLS_GCM_C
//certs
#define MBEDTLS_X509_CRT_PARSE_C
#define MBEDTLS_X509_USE_C
#define MBEDTLS_OID_C
#define MBEDTLS_ASN1_PARSE_C
#define MBEDTLS_ASN1_WRITE_C
//hash methods
#define MBEDTLS_SHA1_C
#define MBEDTLS_SHA224_C
#define MBEDTLS_SHA256_C
#define MBEDTLS_SHA512_C
//TLS
#define MBEDTLS_CIPHER_C
#define MBEDTLS_SSL_TLS_C
#define MBEDTLS_MD_C
//enable client and server modes and TLS
#define MBEDTLS_SSL_CLI_C
#define MBEDTLS_SSL_SERVER_NAME_INDICATION
#define MBEDTLS_SSL_SRV_C
//enable TLS 1.2
#define MBEDTLS_SSL_PROTO_TLS1_2
#include "/home/pi/pico/pico-sdk/lib/mbedtls/include/mbedtls/check_config.h"
Chapter 7
Page 157 Simple UDP server
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/pbuf.h"
#include "lwip/udp.h"
#include "setupWifi.h"
int main()
{
stdio_init_all();
connect();
struct udp_pcb *pcb = udp_new();
udp_bind(pcb, IP_ADDR_ANY, 8080);
ip_addr_t ip;
IP4_ADDR(&ip, 192, 168, 11, 101);
udp_connect(pcb, &ip, 8080);
char message[] = "Hello UDP World";
struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, strlen(message) + 1, PBUF_RAM);
snprintf(p->payload, strlen(message) + 1, "%s", message);
err_t er = udp_send(pcb, p);
pbuf_free(p);
while (true)
{
sleep_ms(500);
}
}
Page 157 Full listing not in book
Simple UDP server lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#define LWIP_DEBUG 1
#endif /* __LWIPOPTS_H__ */
Page 158 Full listing not in book
Simple UDP server Cmakelists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background)
pico_add_extra_outputs(main)
Page 158 Python UDP Client
import asyncio
class ClientDatagramProtocol(asyncio.DatagramProtocol):
def datagram_received(self, data, addr):
message = data.decode("utf8")
print("Received",message,"from", addr)
async def main():
loop = asyncio.get_running_loop()
transport, protocol = await loop.create_datagram_endpoint(
lambda: ClientDatagramProtocol(),
local_addr=('0.0.0.0', 8080))
await asyncio.sleep(100000)
transport.close()
asyncio.run(main())
Page 161 Full listing not in book
Simple UDP client
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/pbuf.h"
#include "lwip/udp.h"
#include "setupWifi.h"
#define BUF_SIZE 1024
void recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
{
char myBuff[BUF_SIZE];
if (p != NULL)
{
printf("recv total %d this buffer %d next %d \n", p->tot_len, p->len, p->next);
printf("From %s:%d\n", ipaddr_ntoa(addr), port);
pbuf_copy_partial(p, myBuff, p->tot_len, 0);
myBuff[p->tot_len] = 0;
printf("Buffer= %s\n", myBuff);
pbuf_free(p);
}
}
int main()
{
stdio_init_all();
connect();
struct udp_pcb *pcb = udp_new();
udp_recv(pcb, recv, NULL);
udp_bind(pcb, IP_ADDR_ANY, 8080);
// ip_addr_t ip;
// IP4_ADDR(&ip, 192, 168, 11, 101);
// IP4_ADDR(&ip, 192, 168, 11, 255);
// udp_connect(pcb, &ip, 8080);
while (true)
{
sleep_ms(500);
}
}
Page 162 Python UDP Server
import asyncio
async def main():
loop = asyncio.get_running_loop()
transport, protocol = await loop.create_datagram_endpoint(
lambda: asyncio.DatagramProtocol(),
local_addr=('0.0.0.0',8080))
data=b"Hello UDP World"
for i in range(20):
transport.sendto(data,addr=("192.168.11.255",8080))
await asyncio.sleep(1)
transport.close()
asyncio.run(main())
Chapter 8
Page 176 SNTP RTC main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/pbuf.h"
#include "lwip/udp.h"
#include "setupWifi.h"
#include "hardware/rtc.h"
#include "time.h"
#include "lwip/dns.h"
bool getDateNow(struct tm *t)
{
datetime_t rtc;
bool state = rtc_get_datetime(&rtc);
if (state)
{
t->tm_sec = rtc.sec;
t->tm_min = rtc.min;
t->tm_hour = rtc.hour;
t->tm_mday = rtc.day;
t->tm_mon = rtc.month - 1;
t->tm_year = rtc.year - 1900;
t->tm_wday = rtc.dotw;
t->tm_yday = 0;
t->tm_isdst = -1;
}
return state;
}
void setRTC(struct tm *datetime)
{
datetime_t t;
t.year = datetime->tm_year + 1900;
t.month = datetime->tm_mon + 1;
t.day = datetime->tm_mday;
t.dotw = datetime->tm_wday;
t.hour = datetime->tm_hour;
t.min = datetime->tm_min;
t.sec = datetime->tm_sec;
rtc_init();
rtc_set_datetime(&t);
}
struct timeStatus
{
bool ready;
struct udp_pcb *pcb;
};
void recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
{
struct timeStatus *tstatus = (struct timeStatus *)arg;
printf("SNTP responded\n");
if (p != NULL)
{
uint8_t seconds_buf[4];
pbuf_copy_partial(p, seconds_buf, sizeof(seconds_buf), 40);
uint32_t seconds_since_1900 = seconds_buf[0] << 24 | seconds_buf[1] << 16 | seconds_buf[2] << 8 | seconds_buf[3];
time_t seconds_since_1970 = seconds_since_1900 - 2208988800;
struct tm *datetime = gmtime(&seconds_since_1970);
setRTC(datetime);
pbuf_free(p);
udp_remove(pcb);
tstatus->pcb=NULL;
tstatus->ready = true;
}
}
bool pollSNTP(struct timeStatus *tstatus)
{
if (tstatus == NULL)
return true;
if (tstatus->ready)
{
free(tstatus);
tstatus = NULL;
return true;
}
return false;
}
void dns_found(const char *name, const ip_addr_t *ip, void *arg)
{
struct timeStatus *tstatus = (struct timeStatus *)arg;
printf("DNS %s\n", ipaddr_ntoa(ip));
struct udp_pcb *pcb = udp_new();
tstatus->pcb = pcb;
udp_recv(pcb, recv, arg);
udp_bind(pcb, IP_ADDR_ANY, 123);
udp_connect(pcb, ip, 123);
struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, 48, PBUF_RAM);
uint8_t *payload = (uint8_t *)p->payload;
memset(payload, 0, 48);
*payload = 0x1b;
err_t er = udp_send(pcb, p);
pbuf_free(p);
}
struct timeStatus *getSNTP()
{
struct timeStatus *tstatus = malloc(sizeof(struct timeStatus));
tstatus->ready = false;
tstatus->pcb=NULL;
ip_addr_t ip;
cyw43_arch_lwip_begin();
err_t err = dns_gethostbyname("time.nist.gov", &ip, dns_found, tstatus);
cyw43_arch_lwip_end();
if (err == ERR_OK)
{
printf("DNS cache %s\n", ipaddr_ntoa(&ip));
dns_found("", &ip, tstatus);
}
return tstatus;
}
void cancelSNTP(struct timeStatus *tstatus)
{
if (tstatus != NULL)
{
udp_remove(tstatus->pcb);
free(tstatus);
tstatus = NULL;
printf("canceled\n");
}
}
int main()
{
stdio_init_all();
connect();
while (true)
{
struct timeStatus *tstatus = getSNTP();
sleep_ms(500);
if (pollSNTP(tstatus))
break;
cancelSNTP(tstatus);
}
while (true)
{
struct tm t;
getDateNow(&t);
char Date[100];
strftime(Date, sizeof(Date), "Date: %a, %d %b %Y %k:%M:%S %Z\r\n", &t);
printf("%s\n", Date);
sleep_ms(5000);
}
}
Page 182 SNTP RTC App main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "hardware/rtc.h"
#include <time.h>
#include "lwip/apps/sntp.h"
void SNTPSetRTC(u32_t t, u32_t us)
{
printf("updating RTC\n");
time_t seconds_since_1970 = t - 2208988800;
struct tm *datetime = gmtime(&seconds_since_1970);
datetime_t dt;
dt.year = datetime->tm_year + 1900;
dt.month = datetime->tm_mon + 1;
dt.day = datetime->tm_mday;
dt.dotw = datetime->tm_wday;
dt.hour = datetime->tm_hour;
dt.min = datetime->tm_min;
dt.sec = datetime->tm_sec;
rtc_init();
rtc_set_datetime(&dt);
}
bool getDateNow(struct tm *t)
{
datetime_t rtc;
bool state = rtc_get_datetime(&rtc);
if (state)
{
t->tm_sec = rtc.sec;
t->tm_min = rtc.min;
t->tm_hour = rtc.hour;
t->tm_mday = rtc.day;
t->tm_mon = rtc.month - 1;
t->tm_year = rtc.year - 1900;
t->tm_wday = rtc.dotw;
t->tm_yday = 0;
t->tm_isdst = -1;
}
return state;
}
int main()
{
stdio_init_all();
connect();
sntp_setoperatingmode(SNTP_OPMODE_POLL);
sntp_setservername(0, "pool.ntp.org");
sntp_init();
while (true)
{
struct tm t;
if (getDateNow(&t)) {
char Date[100];
strftime(Date, sizeof(Date), "Date: %a, %d %b %Y %k:%M:%S %Z\r\n", &t);
printf("%s\n", Date);
}
sleep_ms(5000);
}
}
Page 183 Full listing not in book
SNTP RTC app lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#define SNTP_SERVER_DNS 1
#define SNTP_SUPPORT 1
#define SNTP_UPDATE_DELAY 60*1000
#define SNTP_SET_SYSTEM_TIME_NTP(sec, us) \
void SNTPSetRTC(u32_t, u32_t); \
SNTPSetRTC(sec, us)
#define LWIP_DEBUG 1
#endif /* __LWIPOPTS_H__ */
Page 184 Full listing not in book
SNTP RTC app CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background pico_lwip_sntp hardware_rtc)
pico_add_extra_outputs(main)
Chapter 9
Page 190 SMTP main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "lwip/apps/smtp.h"
void mailsent(void *arg, u8_t smtp_result, u16_t srv_err, err_t err)
{
printf("mail (%p) sent with results: 0x%02x, 0x%04x, 0x%08x\n", arg,
smtp_result, srv_err, err);
}
int main()
{
stdio_init_all();
connect();
smtp_set_server_addr("iopress.info");
smtp_set_server_port(25);
smtp_set_auth(NULL, NULL);
smtp_send_mail("This email address is being protected from spambots. You need JavaScript enabled to view it.", "This email address is being protected from spambots. You need JavaScript enabled to view it.", "subject", "body", mailsent, NULL);
while (true)
{
sleep_ms(10);
}
}
Page 191 Full listing not in book
SMTP CMakelists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background pico_lwip_smtp)
pico_add_extra_outputs(main)
Page 192 Full listing not in book
SMTP lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#define LWIP_DEBUG 1
#define SMTP_DEBUG LWIP_DBG_ON
#endif /* __LWIPOPTS_H__ */
Page 193 SMTPS main
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "setupWifi.h"
#include "lwip/altcp_tls.h"
#include "lwip/apps/smtp.h"
void mailsent(void *arg, u8_t smtp_result, u16_t srv_err, err_t err)
{
printf("mail (%p) sent with results: 0x%02x, 0x%04x, 0x%08x\n", arg,
smtp_result, srv_err, err);
}
int main()
{
stdio_init_all();
connect();
struct altcp_tls_config *tls_config = altcp_tls_create_config_client(NULL, 0);
smtp_set_tls_config(tls_config);
smtp_set_server_addr("smtp.gmail.com");
smtp_set_server_port(465);
smtp_set_auth("gmailUSER", "App Password");
smtp_send_mail("gmailUSER", "email address", "subject", "body", mailsent, NULL);
while (true)
{
sleep_ms(10);
}
}
Page 194 Full listing not in book
SMTPS mbedtls_config.h
//Hardware config
#define MBEDTLS_NO_PLATFORM_ENTROPY
#define MBEDTLS_ENTROPY_HARDWARE_ALT
#define MBEDTLS_HAVE_TIME
//error reporting
#define MBEDTLS_ERROR_C
//used by LwIP
#define MBEDTLS_ENTROPY_C
#define MBEDTLS_CTR_DRBG_C
//EC KEY EXCHANGE
#define MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED
#define MBEDTLS_ECDH_C
#define MBEDTLS_ECDSA_C
#define MBEDTLS_ECP_C
/* Short Weierstrass curves (supporting ECP, ECDH, ECDSA) */
#define MBEDTLS_ECP_DP_SECP192R1_ENABLED
#define MBEDTLS_ECP_DP_SECP224R1_ENABLED
#define MBEDTLS_ECP_DP_SECP256R1_ENABLED
#define MBEDTLS_ECP_DP_SECP384R1_ENABLED
#define MBEDTLS_ECP_DP_SECP521R1_ENABLED
#define MBEDTLS_ECP_DP_SECP192K1_ENABLED
#define MBEDTLS_ECP_DP_SECP224K1_ENABLED
#define MBEDTLS_ECP_DP_SECP256K1_ENABLED
#define MBEDTLS_ECP_DP_BP256R1_ENABLED
#define MBEDTLS_ECP_DP_BP384R1_ENABLED
#define MBEDTLS_ECP_DP_BP512R1_ENABLED
//RSA KEY EXCHANGE
#define MBEDTLS_KEY_EXCHANGE_RSA_ENABLED
#define MBEDTLS_RSA_C
//general key exchange
#define MBEDTLS_PKCS1_V15
#define MBEDTLS_BIGNUM_C
#define MBEDTLS_PK_C
#define MBEDTLS_PK_PARSE_C
//encryption
#define MBEDTLS_AES_C
#define MBEDTLS_CCM_C
#define MBEDTLS_CIPHER_MODE_CBC
#define MBEDTLS_AES_FEWER_TABLES
#define MBEDTLS_GCM_C
//certs
#define MBEDTLS_X509_CRT_PARSE_C
#define MBEDTLS_X509_USE_C
#define MBEDTLS_OID_C
#define MBEDTLS_ASN1_PARSE_C
#define MBEDTLS_ASN1_WRITE_C
//hash methods
#define MBEDTLS_SHA1_C
#define MBEDTLS_SHA224_C
#define MBEDTLS_SHA256_C
#define MBEDTLS_SHA512_C
//ECDHE-RSA-AES256-GCM-SHA384
//TLS
#define MBEDTLS_CIPHER_C
#define MBEDTLS_SSL_TLS_C
#define MBEDTLS_MD_C
//enable client modes and TLS
#define MBEDTLS_SSL_CLI_C
#define MBEDTLS_SSL_SERVER_NAME_INDICATION
//enable TLS 1.2
#define MBEDTLS_SSL_PROTO_TLS1_2
#include "/home/pi/pico/pico-sdk/lib/mbedtls/include/mbedtls/check_config.h"
Page 194 Full listing not in book
SMTPS lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#undef MEM_SIZE
#define MEM_SIZE 8000
#define LWIP_ALTCP 1
#define LWIP_ALTCP_TLS 1
#define LWIP_ALTCP_TLS_MBEDTLS 1
#define LWIP_DEBUG 1
#define ALTCP_MBEDTLS_DEBUG LWIP_DBG_ON
#define SMTP_DEBUG LWIP_DBG_ON
#endif /* __LWIPOPTS_H__ */
Page 194 Full listing not in book
SMTPS CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background pico_lwip_mbedtls
pico_mbedtls pico_lwip_smtp)
pico_add_extra_outputs(main)
Chapter 10
Page 203 MQTT main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/ip_addr.h"
#include "setupWifi.h"
#include "lwip/altcp.h"
#include "lwip/altcp_tls.h"
#include "lwip/apps/mqtt.h"
int mqttStatus = 0;
void mqtt_connection_cb(mqtt_client_t *client, void *arg, mqtt_connection_status_t status)
{
if (status == MQTT_CONNECT_ACCEPTED)
{
mqttStatus = 1;
}
}
static void pub_request_cb(void *arg, err_t result)
{
printf("Publish result: %d\n", result);
mqtt_client_t *client = (mqtt_client_t *)arg;
}
void sub_request_cb(void *arg, err_t result)
{
printf("Subscribe result: %d\n", result);
mqttStatus = 2;
}
static void incoming_publish_cb(void *arg, const char *topic, u32_t tot_len)
{
printf("Topic %s. %d\n", topic, tot_len);
}
static void incoming_data_cb(void *arg, const u8_t *data, u16_t len, u8_t flags)
{
char *payload = (char *)data;
printf("payload\n%.*s\n", len, payload);
}
int main()
{
stdio_init_all();
connect();
struct altcp_tls_config *tls_config = altcp_tls_create_config_client(NULL, 0);
mqtt_client_t *client = mqtt_client_new();
struct mqtt_connect_client_info_t ci;
memset(&ci, 0, sizeof(ci));
ci.client_id = "MyPicoW";
ci.keep_alive = 10;
ci.tls_config = tls_config;
ip_addr_t ip;
IP4_ADDR(&ip, 137, 135, 83, 217);
// IP4_ADDR(&ip, 20, 79, 70, 109);
err_t err = mqtt_client_connect(client, &ip, 8883, mqtt_connection_cb, 0, &ci);
char payload[] = "Hello MQTT World";
u8_t qos = 2;
u8_t retain = 0;
while (true)
{
switch (mqttStatus)
{
case 0:
break;
case 1:
mqtt_set_inpub_callback(client, incoming_publish_cb, incoming_data_cb, NULL);
err = mqtt_subscribe(client, "MyTopic", 1, sub_request_cb, NULL);
break;
case 2:
err = mqtt_publish(client, "MyTopic", payload, strlen(payload), qos, retain, pub_request_cb, client);
break;
}
sleep_ms(2000);
}
}
Page 205 Full listing not in book
MQTT lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#undef MEM_SIZE
#define MEM_SIZE 8000
#define LWIP_ALTCP 1
//#define LWIP_ALTCP_TLS 1
//#define LWIP_ALTCP_TLS_MBEDTLS 1
#define LWIP_DEBUG 1
#define ALTCP_MBEDTLS_DEBUG LWIP_DBG_ON
#define MQTT_DEBUG LWIP_DBG_ON
#define MEMP_NUM_SYS_TIMEOUT (LWIP_NUM_SYS_TIMEOUT_INTERNAL + 1)
#define MQTT_REQ_MAX_IN_FLIGHT (5)
#endif /* __LWIPOPTS_H__ */
Page 205 Full listing not in book
MQTT Cmakelist.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background pico_lwip_mqtt)
pico_add_extra_outputs(main)
Page 205 Full listing not in book
MQTT TLS main program
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/ip_addr.h"
#include "setupWifi.h"
#include "lwip/altcp.h"
#include "lwip/altcp_tls.h"
#include "lwip/apps/mqtt.h"
int mqttStatus = 0;
void mqtt_connection_cb(mqtt_client_t *client, void *arg, mqtt_connection_status_t status)
{
if (status == MQTT_CONNECT_ACCEPTED)
{
mqttStatus = 1;
}
}
static void pub_request_cb(void *arg, err_t result)
{
printf("Publish result: %d\n", result);
mqtt_client_t *client = (mqtt_client_t *)arg;
}
void sub_request_cb(void *arg, err_t result)
{
printf("Subscribe result: %d\n", result);
mqttStatus = 2;
}
static void incoming_publish_cb(void *arg, const char *topic, u32_t tot_len)
{
printf("Topic %s. %d\n", topic, tot_len);
}
static void incoming_data_cb(void *arg, const u8_t *data, u16_t len, u8_t flags)
{
char *payload = (char *)data;
printf("payload\n%.*s\n", len, payload);
}
int main()
{
stdio_init_all();
connect();
struct altcp_tls_config *tls_config = altcp_tls_create_config_client(NULL, 0);
mqtt_client_t *client = mqtt_client_new();
struct mqtt_connect_client_info_t ci;
memset(&ci, 0, sizeof(ci));
ci.client_id = "MyPicoW";
ci.keep_alive = 10;
ci.tls_config = tls_config;
ip_addr_t ip;
IP4_ADDR(&ip, 137, 135, 83, 217);
// IP4_ADDR(&ip, 20, 79, 70, 109);
err_t err = mqtt_client_connect(client, &ip, 8883, mqtt_connection_cb, 0, &ci);
char payload[] = "Hello MQTT World";
u8_t qos = 2;
u8_t retain = 0;
while (true)
{
switch (mqttStatus)
{
case 0:
break;
case 1:
mqtt_set_inpub_callback(client, incoming_publish_cb, incoming_data_cb, NULL);
err = mqtt_subscribe(client, "MyTopic", 1, sub_request_cb, NULL);
break;
case 2:
err = mqtt_publish(client, "MyTopic", payload, strlen(payload), qos, retain, pub_request_cb, client);
break;
}
sleep_ms(2000);
}
}
Page 205 Full listing not in book
MQTT TLS lwipopts.h
#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H
// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
#undef TCP_WND
#define TCP_WND 16384
#undef MEM_SIZE
#define MEM_SIZE 8000
#define LWIP_ALTCP 1
#define LWIP_ALTCP_TLS 1
#define LWIP_ALTCP_TLS_MBEDTLS 1
#define LWIP_DEBUG 1
#define ALTCP_MBEDTLS_DEBUG LWIP_DBG_ON
#define MQTT_DEBUG LWIP_DBG_ON
#define MEMP_NUM_SYS_TIMEOUT (LWIP_NUM_SYS_TIMEOUT_INTERNAL + 1)
#define MQTT_REQ_MAX_IN_FLIGHT (5)
#endif /* __LWIPOPTS_H__ */
Page 205 Full listing not in book
MQTT TLS mbedtls_config.h
//Hardware config
#define MBEDTLS_NO_PLATFORM_ENTROPY
#define MBEDTLS_ENTROPY_HARDWARE_ALT
#define MBEDTLS_HAVE_TIME
//error reporting
#define MBEDTLS_ERROR_C
//used by LwIP
#define MBEDTLS_ENTROPY_C
#define MBEDTLS_CTR_DRBG_C
//EC KEY EXCHANGE
#define MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED
#define MBEDTLS_ECDH_C
#define MBEDTLS_ECDSA_C
#define MBEDTLS_ECP_C
/* Short Weierstrass curves (supporting ECP, ECDH, ECDSA) */
#define MBEDTLS_ECP_DP_SECP192R1_ENABLED
#define MBEDTLS_ECP_DP_SECP224R1_ENABLED
#define MBEDTLS_ECP_DP_SECP256R1_ENABLED
#define MBEDTLS_ECP_DP_SECP384R1_ENABLED
#define MBEDTLS_ECP_DP_SECP521R1_ENABLED
#define MBEDTLS_ECP_DP_SECP192K1_ENABLED
#define MBEDTLS_ECP_DP_SECP224K1_ENABLED
#define MBEDTLS_ECP_DP_SECP256K1_ENABLED
#define MBEDTLS_ECP_DP_BP256R1_ENABLED
#define MBEDTLS_ECP_DP_BP384R1_ENABLED
#define MBEDTLS_ECP_DP_BP512R1_ENABLED
//RSA KEY EXCHANGE
#define MBEDTLS_KEY_EXCHANGE_RSA_ENABLED
#define MBEDTLS_RSA_C
//general key exchange
#define MBEDTLS_PKCS1_V15
#define MBEDTLS_BIGNUM_C
#define MBEDTLS_PK_C
#define MBEDTLS_PK_PARSE_C
//encryption
#define MBEDTLS_AES_C
#define MBEDTLS_CCM_C
#define MBEDTLS_CIPHER_MODE_CBC
#define MBEDTLS_AES_FEWER_TABLES
#define MBEDTLS_GCM_C
//certs
#define MBEDTLS_X509_CRT_PARSE_C
#define MBEDTLS_X509_USE_C
#define MBEDTLS_OID_C
#define MBEDTLS_ASN1_PARSE_C
#define MBEDTLS_ASN1_WRITE_C
//hash methods
#define MBEDTLS_SHA1_C
#define MBEDTLS_SHA224_C
#define MBEDTLS_SHA256_C
#define MBEDTLS_SHA512_C
//ECDHE-RSA-AES256-GCM-SHA384
//TLS
#define MBEDTLS_CIPHER_C
#define MBEDTLS_SSL_TLS_C
#define MBEDTLS_MD_C
//enable client modes and TLS
#define MBEDTLS_SSL_CLI_C
#define MBEDTLS_SSL_SERVER_NAME_INDICATION
//enable TLS 1.2
#define MBEDTLS_SSL_PROTO_TLS1_2
#include "/home/pi/pico/pico-sdk/lib/mbedtls/include/mbedtls/check_config.h"
Page 205 Full listing not in book
MQTT TLS CMakeLists.txt
cmake_minimum_required(VERSION 3.13)
set(PICO_BOARD pico_w)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
include(pico_sdk_import.cmake)
project(PicoW C CXX ASM)
pico_sdk_init()
add_executable(main
main.c
)
target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(main pico_stdlib pico_cyw43_arch_lwip_threadsafe_background pico_lwip_mqtt pico_lwip_mbedtls
pico_mbedtls)
pico_add_extra_outputs(main)
Page 207 MQTT HiveMQ main program Note works with modified mqtt.h and mqtt.c
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/ip_addr.h"
#include "setupWifi.h"
#include "lwip/altcp.h"
#include "lwip/altcp_tls.h"
#include "lwip/apps/mqtt.h"
int mqttStatus = 0;
void mqtt_connection_cb(mqtt_client_t *client, void *arg, mqtt_connection_status_t status)
{
if (status == MQTT_CONNECT_ACCEPTED)
{
mqttStatus = 1;
}
}
static void pub_request_cb(void *arg, err_t result)
{
printf("Publish result: %d\n", result);
mqtt_client_t *client = (mqtt_client_t *)arg;
}
void sub_request_cb(void *arg, err_t result)
{
printf("Subscribe result: %d\n", result);
mqttStatus = 2;
}
static void incoming_publish_cb(void *arg, const char *topic, u32_t tot_len)
{
printf("Topic %s. %d\n", topic, tot_len);
}
static void incoming_data_cb(void *arg, const u8_t *data, u16_t len, u8_t flags)
{
char *payload = (char *)data;
printf("payload\n%.*s\n", len, payload);
}
int main()
{
stdio_init_all();
connect();
struct altcp_tls_config *tls_config = altcp_tls_create_config_client(NULL, 0);
mqtt_client_t *client = mqtt_client_new();
struct mqtt_connect_client_info_t ci;
memset(&ci, 0, sizeof(ci));
ci.client_id = "MyPicoW";
ci.client_user = "username";
ci.client_pass = "password";
ci.keep_alive = 10;
ci.tls_config = tls_config;
strncpy(ci.domName, "1a6d2dccd35744888e4b7c6f8e65f613.s2.eu.hivemq.cloud", 100);
ip_addr_t ip;
// IP4_ADDR(&ip, 137, 135, 83, 217);
IP4_ADDR(&ip, 20, 79, 70, 109);
err_t err = mqtt_client_connect(client, &ip, 8883, mqtt_connection_cb, 0, &ci);
char payload[] = "Hello MQTT World";
u8_t qos = 2;
u8_t retain = 0;
while (true)
{
switch (mqttStatus)
{
case 0:
break;
case 1:
mqtt_set_inpub_callback(client, incoming_publish_cb, incoming_data_cb, NULL);
err = mqtt_subscribe(client, "MyTopic", 1, sub_request_cb, NULL);
break;
case 2:
err = mqtt_publish(client, "MyTopic", payload, strlen(payload), qos, retain, pub_request_cb, client);
break;
}
sleep_ms(2000);
}
}
Programming the ESP32 in MicroPython
We have decided not to make the programs available as a download because this is not the point of the book - the programs are not finished production code but something you should type in and study.
The best solution is to provide the source code of the programs in a form that can be copied and pasted into Thonny or Pycharm project.
The only downside is that you have to create a project to paste the code into.
To do this follow the instructions in the book.
All of the programs below were copy and pasted from working programs in the IDE. They have been formatted using the built in formatter and hence are not identical in layout to the programs in the book. This is to make copy and pasting them easier. The programs in the book are formatted to be easy to read on the page.
If anything you consider important is missing or if you have any requests or comments contact:
This email address is being protected from spambots. You need JavaScript enabled to view it.
Page 44
from machine import Pin
import time
pin = Pin(2, Pin.OUT)
while True:
pin.value(1)
time.sleep(1)
pin.value(0)
time.sleep(1)
Page 46
from machine import Pin
import time
def toggle(pin):
temp = pin.value()
temp = not temp
pin.value(temp)
pin = Pin(2,Pin.OUT)
while True:
toggle(pin)
time.sleep(1)
Page 50
from machine import Pin
pin = Pin(6, Pin.OUT)
while True:
pin.value(1)
pin.value(0)
Page 51
from machine import Pin
def flash():
pin = Pin(2, Pin.OUT)
while True:
pin.value(1)
pin.value(0)
flash()
Page 51
from machine import Pin
@micropython.native
def flash():
pin = Pin(2, Pin.OUT)
while True:
pin.value(1)
pin.value(0)
flash()
Page 52
from machine import Pin
import time
pin = Pin(2, Pin.OUT)
while True:
pin.value(1)
time.sleep(0.5)
pin.value(0)
time.sleep(0.5)
Page 53
from machine import Pin
import time
pin = Pin(2, Pin.OUT)
while True:
pin.value(1)
time.sleep_us(10)
pin.value(0)
time.sleep_us(10)
Page 53
from machine import Pin
import time
pin = Pin(2, Pin.OUT)
n = 10
while True:
for i in range(n):
pass
pin.value(1)
for i in range(n):
pass
pin.value(0)
Page 54
from machine import Pin
import time
pin = Pin(2, Pin.OUT)
n = 5
while True:
t = time.ticks_add(time.ticks_us(), 1000)
pin.value(1)
for i in range(n):
pass
while time.ticks_us() < t:
pass
pin.value(0)
Page 56
import time
from time import sleep
import esp32
from machine import Pin
import machine
pin = Pin(2,Pin.OUT,value=0)
buf = bytearray(b"\x55\x55")
print(buf)
machine.bitstream(pin,0,(80,90,100,110),buf)
Page 58
import esp32
from machine import Pin
import machine
pin=Pin(2,Pin.OUT,value=0)
rmt=esp32.RMT(0,pin=pin)
rmt.write_pulses((1000,400,200,300,200,300),1)
Page 59
from machine import Pin
pin1 = Pin(2, Pin.OUT)
pin2 = Pin(4, Pin.OUT)
while True:
pin1.value(1)
pin2.value(0)
pin1.value(0)
pin2.value(1)
Page 61
from machine import Pin
import machine
def gpio_set(value, mask):
machine.mem32[0x3FF44004] = machine.mem32[0x3FF44004] & ~mask | value & mask
pin = Pin(2, Pin.OUT)
pin = Pin(4, Pin.OUT)
value1 = 1 << 2 | 0 << 4
value2 = 0 << 2 | 1 << 4
mask = 1 << 2 | 1 << 4
while True:
gpio_set(value1, mask)
gpio_set(value2, mask)
Page 83
from machine import Pin
import time
pinIn = Pin(4, Pin.IN,Pin.PULL_UP)
pinLED = Pin(2, Pin.OUT)
while True:
if pinIn.value():
pinLED.on()
else:
pinLED.off()
time.sleep(0.5)
Page 84
from machine import Pin
import time
pinIn = Pin(4, Pin.IN,Pin.PULL_DOWN)
pinLED = Pin(2, Pin.OUT)
while True:
while pinIn.value()==0:
pass
while pinIn.value()==1:
pass
pinLED.on()
time.sleep_ms(1)
pinLED.off()
Page 85
from machine import Pin
import time
pinIn = Pin(4, Pin.IN,Pin.PULL_DOWN)
pinLED = Pin(2, Pin.OUT)
while True:
while pinIn.value() == 0:
pass
t = time.ticks_ms()
time.sleep_ms(1)
while pinIn.value() == 1:
pass
t = time.ticks_diff(time.ticks_ms(),t)
if t<2000:
pinLED.on()
time.sleep(1)
pinLED.off()
else:
for i in range(10):
pinLED.on()
time.sleep_ms(100)
pinLED.off()
time.sleep_ms(100)
Page 86
from machine import Pin
import time
pinIn = Pin(4, Pin.IN)
while True:
while pinIn.value()==1:
pass
while pinIn.value()==0:
pass
t=time.ticks_us()
while pinIn.value()==1:
pass
t=time.ticks_diff(time.ticks_us(),t)
print(t)
time.sleep(1)
Page 87
import time
import machine
pinIn = machine.Pin(4, machine.Pin.IN)
while True:
t = machine.time_pulse_us(pinIn, 1)
print(t)
time.sleep(1)
Page 87
import time
import machine
pinIn = machine.Pin(4, machine.Pin.IN)
while True:
while pinIn.value() == 1:
pass
t = machine.time_pulse_us(pinIn, 1)
print(t)
time.sleep(1)
Page 90
from machine import Pin
import time
pinIn = Pin(4, Pin.IN)
s = 0
count = 0
while True:
I = pinIn.value()
t = time.ticks_add(time.ticks_us(),1000*100)
if s == 0: #button not pushed
if i:
s = 1
count=count+1
print("Button Push ",count)
elif s == 1: #button pushed
if not i:
s = 0
else:
s = 0
while time.ticks_us()<t:
pass
Page 92
from machine import Pin
import time
pinIn = Pin(4, Pin.IN)
s = 0
while True:
I = pinIn.value()
t = time.ticks_add(time.ticks_us(),1000*100)
if s == 0: #button not pushed
if i:
s = 1
tpush = t
elif s == 1: #button pushed
if not i:
s = 0
if time.ticks_diff(t, tpush) > 2000000:
print("Button held \n\r")
else:
print("Button pushed \n\r")
else:
s = 0
while time.ticks_us()<t:
pass
Page 93
from machine import Pin
import time
pinIn = Pin(4, Pin.IN)
pinLED1 = Pin(2, Pin.OUT)
pinLED2 = Pin(16, Pin.OUT)
pinLED3 = Pin(17, Pin.OUT)
pinLED1.on()
pinLED2.off()
pinLED3.off()
s = 0
buttonState = pinIn.value()
while True:
buttonNow = pinIn.value()
edge = buttonState-buttonNow
buttonState = buttonNow
t = time.ticks_add(time.ticks_us(), 1000*100)
if s == 0:
if edge == 1:
s = 1
pinLED1.off()
pinLED2.on()
pinLED3.off()
elif s == 1:
if edge == 1:
s = 2
pinLED1.off()
pinLED2.off()
pinLED3.on()
elif s == 2:
if edge == 1:
s = 0
pinLED1.on()
pinLED2.off()
pinLED3.off()
else:
s = 0
while time.ticks_us() < t:
pass
Page 100
def HelloIRQ1(pin):
print("IRQ1")
def HelloIRQ2(pin):
print("IRQ2")
pin1=Pin(4,Pin.IN,Pin.PULL_DOWN)
pin2=Pin(5,Pin.IN,Pin.PULL_DOWN)
pin1.irq(HelloIRQ1,Pin.IRQ_RISING)
pin2.irq(HelloIRQ2,Pin.IRQ_RISING)
Page 101
import time
from machine import Pin
t = 0
def myHandler(pin):
global t
temp = time.ticks_us()
print(time.ticks_diff(temp,t))
t = temp
time.sleep(1.5)
return
pin = Pin(4, Pin.IN, Pin.PULL_DOWN)
pin.irq(myHandler, Pin.IRQ_FALLING)
Page 101
import time
from machine import Pin
t = 0
def myHandler(pin):
global t
pin.irq(None, Pin.IRQ_FALLING)
temp = time.ticks_us()
print(time.ticks_diff(temp,t))
t = temp
time.sleep(1.5)
pin.irq(myHandler, Pin.IRQ_FALLING)
return
pin = Pin(4, Pin.IN, Pin.PULL_DOWN)
pin.irq(myHandler, Pin.IRQ_FALLING)
Page 104
import time
from machine import Pin
data = bytearray(b'\xf0\xf1\xf2')
def myHandler(pin):
global data
for i in range(3):
data[i]=0
pin = Pin(4, Pin.IN, Pin.PULL_DOWN)
pin.irq(myHandler, Pin.IRQ_RISING)
while True:
for i in range(3):
data[i] = 255
if data[0]!=data[1] or data[1]!=data[2] or data[2]!=data[0]:
print(data)
Page 105
from machine import Pin
data=bytearray(b'\xf0\xf1\xf2')
def myHandler(pin):
global data
for i in range(3):
data[i] = 0
print(data)
pin = Pin(4, Pin.IN, Pin.PULL_DOWN)
pin.irq(myHandler, Pin.IRQ_RISING)
while True:
pin.irq(None, Pin.IRQ_RISING)
for i in range(3):
data[i] = 255
if data[0]!=data[1] or data[1]!=data[2] or data[2]!=data[0]:
print(data)
pin.irq(myHandler, Pin.IRQ_RISING)
Page 106
import time
from time import sleep
from machine import Pin
pin=Pin(4,Pin.IN,Pin.PULL_DOWN)
event=0
def rise(pin):
global event
event=1
def fall(pin):
global event
event=2
while True:
pin.irq(rise, Pin.IRQ_RISING)
while not(event==1):
pass
t=time.ticks_us()
pin.irq(fall, Pin.IRQ_FALLING)
while not(event==2):
pass
t=time.ticks_diff(time.ticks_us(),t)
print(t)
sleep(1)
Page 114
import esp32
from machine import Pin
import machine
pin=Pin(4,Pin.OUT,value=0)
rmt=esp32.RMT(0,pin=pin)
t=20000000 # pulse repetition in us
d=[10,20,30,40,50] #duty cycles in percent
times=[]
for p in d:
times.append(int(t*p/100))
times.append(int((t*(100-p)/100)))
rmt.loop(True)
rmt.write_pulses(times,1)
Page 117
from machine import Pin, PWM
import array
import math
wave = array.array('H', [0]*256)
for i in range(256):
wave[i] = int(65535//2 + (math.sin(i * 2.0 * 3.14159 / 256.0) * 65535//2))
pwm1 = PWM(Pin(4),freq=300000)
print(pwm1)
while(True):
for i in range(256):
pwm1.duty_u16(wave[i])
print(pwm_get_wrap(0))
while(True):
for i in range(256):
pwm16.duty_u16(wave[i])
Page 119
from machine import Pin, PWM
from time import sleep_ms
pwm1 = PWM(Pin(4),freq=2000)
while True:
for d in range(0,65535,655):
pwm1.duty_u16(d)
sleep_ms(50)
Page 120
from utime import sleep_ms
from machine import Pin, PWM
pwm1 = PWM(Pin(4),freq=2000)
while True:
for b in range(0,100):
pwm1.duty_u16(int(65535*b*b*b/1000000))
sleep_ms(50)
Page 131
from machine import Pin, PWM
from time import sleep
class Motor:
def __init__(self, pinNo):
self.pwm1 = PWM(Pin(pinNo), freq=2000, duty_u16=0)
self.gpio = pinNo
self._on = False
self.speed=0
def setSpeed(self,s):
self._on=True
self.speed=s
self.pwm1.duty_u16(int(65535*s/100))
def off(self):
self._on=False
self.pwm1.duty_u16(0)
def on(self):
self._on=True
self.pwm1.duty_u16(int(65535*self.speed/100))
motor=Motor(4)
sleep(1)
motor.setSpeed(50)
sleep(1)
motor.off()
sleep(1)
motor.setSpeed(90)
sleep(1)
motor.off()
Page 136
from machine import Pin, PWM
from time import sleep
class Motor:
def __init__(self, pinNo):
self.pwm1 = PWM(Pin(pinNo), freq=2000, duty_u16=0)
self.gpio = pinNo
self._on = False
self.speed=0
def setSpeed(self,s):
self._on=True
self.speed=s
self.pwm1.duty_u16(int(65535*s/100))
def off(self):
self._on=False
self.pwm1.duty_u16(0)
def on(self):
self._on=True
self.pwm1.duty_u16(int(65535*self.speed/100))
class BiMotor(Motor):
def __init__(self, pinNo1,pinNo2):
super().__init__(pinNo1)
self.forward = True
self.pwm2 = PWM(Pin(pinNo2),freq=2000,duty_u16=0)
def setForward(self, forward):
if self.forward == forward:
return
self.pwm1.duty_u16(0)
self.pwm1, self.pwm2 = self.pwm2, self.pwm1
self.forward = forward
self.pwm1.duty_u16(int(65535 * self.speed / 100))
motor = BiMotor(16,17)
sleep(1)
motor.setSpeed(50)
sleep(1)
motor.setForward(False)
sleep(1)
motor.setSpeed(90)
sleep(1)
motor.setForward(True)
motor.off()
Page 139
from machine import Pin, PWM
from time import sleep
class Servo:
def __init__(self, pinNo):
self.pwm = PWM(Pin(pinNo),freq=50,duty_u16= int(65535*2.5/100))
def setPosition(self, p):
self.position = p
self.pwm.duty_u16(int(65535*p/1000 + 65535*2.5/100))
def off(self):
self.pwm.deinit()
servo=Servo(4)
sleep(1)
servo.setPosition(100.0)
sleep(1)
servo.setPosition(50.0)
sleep(1)
servo.setPosition(0)
sleep(1)
servo.off()
Page 146
from machine import Pin, mem32
from time import sleep_ms
class StepperBi4():
def __init__(self, pinA):
self.phase = 0
self.pinA = pinA
self.gpios = tuple([Pin(pinA, Pin.OUT),
Pin(pinA + 1, Pin.OUT),
Pin(pinA + 2, Pin.OUT),
Pin(pinA + 3, Pin.OUT)])
self.gpios[0].on()
self.gpioMask = 0xF << self.pinA
self.halfstepSeq = [0x1, 0x3, 0x2, 0x6, 0x4, 0xC, 0x8, 0x9]
# [
# [0,0,0,1],
# [0,0,1,1],
# [0,0,1,0],
# [0,1,1,0],
# [0,1,0,0],
# [1,1,0,0],
# [1,0,0,0],
# [1,0,0,1]
# ]
def _gpio_set(self,value, mask):
mem32[0x3FF44004] = mem32[0x3FF44004] & ~mask | value & mask
def setPhase(self, phase):
value = self.halfstepSeq[phase] << self.pinA
self._gpio_set(value, self.gpioMask)
self.phase = phase
def stepForward(self):
self.phase = (self.phase + 1) % 8
self.setPhase(self.phase)
def stepReverse(self):
self.phase = (self.phase - 1) % 8
self.setPhase(self.phase)
step = StepperBi4(16)
step.setPhase(0)
while True:
step.stepForward()
sleep_ms(1)
Page 151
from machine import Pin, mem32, Timer
from time import sleep_ms
class StepperBi4():
def __init__(self, pinA):
self.phase = 0
self.pinA = pinA
self.gpios = tuple([Pin(pinA, Pin.OUT),
Pin(pinA + 1, Pin.OUT),
Pin(pinA + 2, Pin.OUT),
Pin(pinA + 3, Pin.OUT)])
self.gpios[0].on()
self.gpioMask = 0xF << self.pinA
self.halfstepSeq = [0x1, 0x3, 0x2, 0x6, 0x4, 0xC, 0x8, 0x9]
self.timer = None
self.forward = True
# [
# [0,0,0,1],
# [0,0,1,1],
# [0,0,1,0],
# [0,1,1,0],
# [0,1,0,0],
# [1,1,0,0],
# [1,0,0,0],
# [1,0,0,1]
# ]
def _gpio_set(self,value, mask):
mem32[0x3FF44004] = mem32[0x3FF44004] & ~mask | value & mask
def setPhase(self, phase):
value = self.halfstepSeq[phase] << self.pinA
self._gpio_set(value, self.gpioMask)
self.phase = phase
def stepForward(self):
self.phase = (self.phase + 1) % 8
self.setPhase(self.phase)
def stepReverse(self):
self.phase = (self.phase - 1) % 8
self.setPhase(self.phase)
def doRotate(self, timer):
if self.forward:
self.stepForward()
else:
self.stepReverse()
def rotate(self, forward, speed):
self.forward = forward
self.speed = speed
if speed == 0:
self.timer.deinit()
self.timer = None
return
if self.timer == None:
self.timer = Timer(0)
self.timer.init(freq = speed, mode = Timer.PERIODIC, callback = self.doRotate)
step=StepperBi4(16)
step.setPhase(0)
while True:
step.rotate(True,100)
sleep_ms(500)
step.rotate(True,0)
sleep_ms(500)
Page 160
from machine import Pin, SPI
spi=SPI(1,sck=Pin(14),miso=Pin(12),mosi=Pin(13))
spi.init(baudrate=500_000,bits=8, polarity=0,phase=0,firstbit=SPI.MSB )
read = bytearray(3)
write = bytearray([0xAA,0xAA,0xAA])
spi.write_readinto(write,read)
print(read,write)
spi.deinit()
Page 168
from utime import sleep_ms
from machine import Pin, SPI
spi=SPI(1,sck=Pin(14),miso=Pin(12),mosi=Pin(13))
spi.init(baudrate=500_000, bits=8, polarity=0, phase=0,firstbit=SPI.MSB)
CS = Pin(15, Pin.OUT)
CS.on()
sleep_ms(1)
CS.off()
write=bytearray([0x01, 0x80, 0x00])
read=bytearray(3)
spi.write_readinto(write,read)
CS.on()
data = (read[1] & 0x03) << 8 | read[2]
volts = data * 3.3 / 1023.0
print(volts)
spi.deinit()
Page 169
from utime import sleep_ms
from machine import Pin, SPI
class spiADC:
def __init__(self,spi,sckNo,misoNo,mosiNo,CSNo):
self.spi = SPI(spi, sck=Pin(sckNo), miso=Pin(misoNo), mosi=Pin(mosiNo))
self.spi.init(baudrate=500_000, bits=8, polarity=0,phase=0, firstbit=SPI.MSB)
self.CS = Pin(CSNo, Pin.OUT)
self.CS.on()
sleep_ms(1)
def read(self,chan):
write=bytearray([0x01, (0x08 | chan) << 4 , 0x00])
self.CS.off()
read=bytearray(3)
self.spi.write_readinto(write,read)
self.CS.on()
data = (read[1] & 0x03) << 8 | read[2]
volts = data * 3.3 / 1023.0
return volts
adc=spiADC(1,14,12,13,15)
volts=adc.read(1)
print(volts)
Page 173
from machine import mem32
def getVCal():
VC=(mem32[0x3FF5_A010]>>8)& 0x1F
if(VC & 0x10 ):
VC=-(VC & 0x0F)
return 1100+VC*7
print(getVCal())
Page 177
from machine import ADC,Pin
import time
adc = ADC(Pin(32),atten=ADC.ATTN_11DB)
t = time.ticks_us()
for i in range(10000):
pass
print(time.ticks_diff(time.ticks_us(), t)/10000)
t = time.ticks_us()
for i in range(10000):
m=adc.read()
print(time.ticks_diff(time.ticks_us(), t)/10000)
t = time.ticks_us()
for i in range(10000):
m=adc.read_u16()
print(time.ticks_diff(time.ticks_us(), t)/10000)
t = time.ticks_us()
for i in range(10000):
m=adc.read_uv()
print(time.ticks_diff(time.ticks_us(), t)/10000)
Page 178
import esp32
import time
while(True):
m = esp32.hall_sensor()+esp32.hall_sensor()+esp32.hall_sensor()+esp32.hall_sensor()
m = m/4
print(m)
time.sleep(0.5)
Page 181
from machine import Pin, DAC
import math
dac1 = DAC(Pin(26))
wave = []
for i in range(0,255):
wave.append(int(127*math.sin(2*math.pi/256*i))+128)
while(True):
for i in range(0,255):
dac1.write(wave[i])
Page 181
from machine import Pin, DAC, mem32
from time import sleep
def _gpio_get(adr):
return mem32[adr]
def _gpio_set( adr,value, mask):
mem32[adr] = mem32[adr] & ~mask | value & mask
def enableSin(chan,f):
if chan<1 or chan>2:
return
setFreq(chan, f)
setPhase(chan,0x2)
#enable tone
_gpio_set(0x3FF48898, 0x10000, 0x10000)
#select channel
if chan==1:
_gpio_set(0x3FF4889c, 1<<24,0x1<<24)
else:
_gpio_set(0x3FF4889c, 1<<25, 0x1 <<25)
#set pad
pad=0x3FF48484+4*(chan-1)
_gpio_set(pad, 0x20200, 0x23A00)
def setFreq(chan,f):
if chan<1 or chan>2:
return
step=int(f*65536/8000000) & 0xFFFF
_gpio_set(0x3FF48898, step, 0x000FF)
def setPhase(chan,p):
_gpio_set(0x3FF4889c, p << (20 + 2 * (chan – 1)),0x03 << (20 + 2 * (chan - 1)))
def setScale(chan,s):
_gpio_set(0x3FF4889c, s << (16 + 2 * (chan – 1)),0x03 << (16 + 2 * (chan - 1)))
def setOff(chan,off):
_gpio_set(0x3FF4889c, off << (8 * (chan – 1)), 0xFF << (8 * (chan - 1)))
dac1 = DAC(Pin(26))
enableSin(2,30000)
setScale(2,0x0)
setOff(2,0x0)
while(True):
sleep(0.001)
setPhase(2,0x3)
sleep(.001)
setPhase(2, 0x2)
Page 197
from machine import Pin,I2C
i2c0 = I2C(0,scl=Pin(18),sda=Pin(19),freq=100000)
buf = bytearray([0xE7])
i2c0.writeto( 0x40, buf, True)
read= i2c0.readfrom(0x40, 1, True)
print("User Register =",read)
Page 199
from machine import Pin,I2C
i2c0 = I2C(0,scl=Pin(18),sda=Pin(19),freq=100000)
buf = bytearray([0xE3])
i2c0.writeto( 0x40, buf, True)
read = i2c0.readfrom(0x40, 3, True)
msb = read[0]
lsb = read[1]
check = read[2]
print("msb lsb checksum =", msb, lsb, check)
Page 200
from machine import Pin,SoftI2C
i2c0 = SoftI2C(scl=Pin(18),sda=Pin(19),freq=100000)
buf = bytearray([0xE3])
i2c0.writeto( 0x40, buf, False)
read= i2c0.readfrom(0x40, 3, True)
msb = read[0]
lsb = read[1]
check = read[2]
print("msb lsb checksum =", msb, lsb, check)
Page 201
from machine import Pin,I2C
i2c0=I2C(0,scl=Pin(18),sda=Pin(19),freq=100000)
buf = bytearray([0xF3])
i2c0.writeto( 0x40, buf, True)
while True:
try:
read= i2c0.readfrom(0x40, 3, False)
break
except:
continue
msb = read[0]
lsb = read[1]
check = read[2]
print("msb lsb checksum =", msb, lsb, check)
Page 202
from machine import Pin,SoftI2C
from time import sleep_ms
i2c0 = SoftI2C(scl=Pin(18),sda=Pin(19),freq=100000)
buf = bytearray([0xF3])
i2c0.writeto( 0x40, buf, False)
while True:
sleep_ms(5)
try:
read = i2c0.readfrom(0x40, 3, True)
break
except:
continue
msb = read[0]
lsb = read[1]
check = read[2]
print("msb lsb checksum =", msb, lsb, check)
Page 206
from machine import Pin,I2C
def crcCheck(msb, lsb,check):
data32 = (msb << 16)|(lsb <<8)| check
divisor = 0x988000
for i in range(16):
if data32 & 1<<(23 - i):
data32 ^= divisor
divisor>>= 1
return data32
i2c0=I2C(0,scl=Pin(18),sda=Pin(19),freq=100000)
buf = bytearray([0xF3])
i2c0.writeto( 0x40, buf, False)
while True:
try:
read= i2c0.readfrom(0x40, 3, True)
break
except:
continue
msb = read[0]
lsb = read[1]
check = read[2]
print("msb lsb checksum =", msb, lsb, check)
data16= (msb << 8) | (lsb & 0xFC)
temp = (-46.85 +(175.72 * data16 /(1<<16)))
print("Temperature C ", temp)
print("Checksum=",crcCheck(msb,lsb,check))
buf = bytearray([0xF5])
i2c0.writeto( 0x40, buf, True)
read=bytearray(3)
while True:
try:
i2c0.readfrom_into(0x40,read, True)
break
except:
continue
msb = read[0]
lsb = read[1]
check = read[2]
print("msb lsb checksum =", msb, lsb, check)
data16 = (msb << 8) | (lsb & 0xFC)
hum = -6 + (125.0 * data16) / 65536
print("Humidity ", hum)
print("Checksum=",crcCheck(msb,lsb,check))
Page 212
import dht
from machine import Pin
from time import sleep
dht = dht.DHT22(Pin(23))
while True:
dht.measure()
temp = dht.temperature()
print(temp,"C")
hum = dht.humidity()
print(hum,"%")
sleep(1)
Page 213
from machine import Pin
from utime import sleep_ms
DHT = Pin(23,mode=Pin.OUT,value=1)
sleep_ms(1)
DHT.off()
sleep_ms(1)
DHT.init(mode=Pin.IN)
Page 217
from machine import Pin,time_pulse_us
from utime import sleep_ms
class DHT22():
def __init__(self,gpio):
self.pin = Pin(gpio, mode=Pin.IN)
self.checksum = 0
self.temperature = 0
self.humidity=0
sleep_ms(1)
@micropython.native
def getReading(self):
data = 0
checksum = 0
DHT=self.pin
DHT.init(mode=Pin.OUT,value=0)
sleep_ms(1)
DHT.init(mode=Pin.IN)
t = time_pulse_us(DHT, 0, 1000)
t = time_pulse_us(DHT, 1, 1000)
for i in range(32):
t = time_pulse_us(DHT, 1, 1000)
data = data << 1
data = data | (t > 50)
for i in range(8):
t = time_pulse_us(DHT, 1, 1000)
checksum = checksum << 1
checksum = checksum |(t > 50)
byte1 = (data >> 24 & 0xFF)
byte2 = (data >> 16 & 0xFF)
byte3 = (data >> 8 & 0xFF)
byte4 = (data & 0xFF)
self.checksum =(checksum ==(byte1+byte2+byte3+byte4)&0xFF)
self.humidity = ((byte1 <<8)| byte2) / 10.0
neg = byte3 & 0x80
byte3 = byte3 & 0x7F
self.temperature = (byte3 << 8 | byte4) / 10.0
if neg > 0:
self.temperature = -self.temperature
dht = DHT22(23)
dht.getReading()
print("Checksum",dht.checksum)
print("Humidity= ", dht.humidity)
print("Temperature=", dht.temperature)
Page 223
from machine import Pin
import onewire,ds18x20
ow = onewire.OneWire(Pin(23))
presence=ow.reset()
if presence:
print("Device present")
else:
print("No device")
ds = ds18x20.DS18X20(ow)
roms = ds.scan()
t = ds.read_temp(roms[0])
print(t)
Page 230
from machine import Pin
import onewire
class DS18B20:
def __init__(self,pin):
self.ow = onewire.OneWire(Pin(pin))
def __convert(self):
self.ow.write([0xCC,0x44])
for i in range(500):
sleep_ms(10)
if self.ow.readbit() == 1:
j = i
break
return j
def getTemp(self):
if not self.ow.reset:
return -1000
if self.__convert()==500:
return -3000
self.ow.reset()
self.ow.write([0xCC,0xBE])
data = bytearray(9)
self.ow.readinto(data)
if self.ow.crc8(data)!=0:
return -2000
t1 = data[0]
t2 = data[1]
temp1 = (t2 << 8 | t1)
if t2 & 0x80:
temp1=temp1 | 0xFFFF0000
return temp1/16
dS18B20=DS18B20(23)
print(dS18B20.getTemp())
Page 239
from machine import UART,Pin
uart = UART(1,baudrate=9600,bits=8,parity=None,rx=23,tx=22)
SendData = bytearray("Hello World \n","utf-8")
uart.write(SendData)
RecData = uart.read()
print(RecData)
Page 242
from machine import UART,Pin, Timer
from utime import sleep_ms,sleep, time_ns
uart = UART(1,baudrate=9600,bits=8,parity=None,rx=23,tx=22,txbuf=256,rxbuf=16*1024)
test="A"*252
s = time_ns()
uart.write(test)
print((time_ns()-s)/1000000)
Page 242
from machine import UART,Pin, Timer
from utime import sleep_ms,sleep, time_ns
uart = UART(1,baudrate=9600,bits=8,parity=None, rx=23,tx=22, txbuf=16*1024,rxbuf=512)
test="A"*1000
s = time_ns()
uart.write(test)
print((time_ns()-s)/1000000)
sleep_ms(4000)
RecData = uart.read()
print(RecData)
Page 243
from machine import UART,Pin, Timer
from utime import sleep_ms,sleep, time_ns
uart = UART(1,baudrate=9600,bits=8,parity=None,rx=23,tx=22, txbuf=4*1024,rxbuf=512)
test = ""
for i in range(280):
test=test + str(i)+","
print(test)
print(len(test))
s = time_ns()
uart.write(test)
print((time_ns()-s)/1000000)
sleep_ms(4000)
RecData = uart.read()
print(RecData)
print(len(RecData))
Page 247
from machine import UART,Pin
from utime import sleep_ms, time_ns
uart = UART(1,baudrate=9600,bits=8,parity=None, rx=23,tx=22,rts=21,cts=19, timeout=0,timeout_char=0,txbuf=2000,rxbuf=256,flow=UART.RTS|UART.CTS)
test = "A"*1000
s = time_ns()
uart.write(test)
print((time_ns()-s)/1000000)
RecData = bytes()
while len(RecData)<1000:
sleep_ms(500)
if uart.any():
RecData = RecData + uart.read()
print(RecData)
print(len(RecData))
Page 257
import network
from machine import Pin, Timer
from time import sleep_ms
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
Page 261
from http.server import HTTPServer, BaseHTTPRequestHandler
from io import BytesIO
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def sendResponse(self, cmd):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length)
self.send_response(200)
self.end_headers()
response = BytesIO()
response.write(b'This is a '+bytes(cmd, 'utf-8')+ b' request. ')
response.write(b'Received: ')
response.write(body)
self.wfile.write(response.getvalue())
def do_GET(self):
self.send_response(200)
self.end_headers()
self.wfile.write(b'Hello, world!')
def do_HEAD(self):
self.send_response(200)
self.end_headers()
def do_POST(self):
self.sendResponse("POST")
def do_PUT(self):
self.sendResponse("PUT")
def do_DELETE(self):
self.sendResponse("DELETE")
def do_PATCH(self):
self.sendResponse("PATCH")
httpd = HTTPServer(('', 8080), SimpleHTTPRequestHandler)
httpd.serve_forever()
Page 264
import network
from machine import Pin, Timer
from time import sleep_ms
import urequests
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
wifi=setup(country, ssid, key)
print("Connected")
r = urequests.get("https://www.example.com")
print(r.content)
r.close()
Page 265
import network
from machine import Pin, Timer
from time import sleep_ms
import urequests
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
wifi=setup(country, ssid, key)
print("Connected")
url="http://192.168.253.72:8080"
r = urequests.get(url)
print(r.content)
r.close()
buf= b'Hello World'
r=urequests.post(url,data=buf)
print(r.content)
r.close()
r=urequests.put(url,data=buf)
print(r.content)
r.close()
r=urequests.patch(url,data=buf)
print(r.content)
r.close()
r=urequests.head(url)
print(r.content)
print(r.headers)
r.close()
r=urequests.delete(url,data=buf)
print(r.content)
r.close()
Page 266
import network
from machine import Pin, Timer
from time import sleep_ms
import urequests
import onewire
import ds18x20
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
wifi=setup(country, ssid, key)
print("Connected")
url = "http://192.168.253.72:8080"
ow = onewire.OneWire(Pin(22))
presence = ow.reset()
if presence:
print("Device present")
else:
print("No device")
DS = ds18x20.DS18X20(ow)
roms = DS.scan()
while True:
DS.convert_temp()
temp = DS.read_temp(roms[0])
buf = str(temp).encode("utf-8")
try:
r = urequests.put(url, data=buf)
r.close()
except:
print("Server Not Online")
sleep_ms(500)
Page 267
from http.server import HTTPServer, BaseHTTPRequestHandler
from io import BytesIO
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def log_message(self,*args, **kwargs):
pass
def do_PUT(self):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length)
bodyString= body.decode(encoding="utf-8")
temp=float(bodyString)
print(temp)
self.send_response(200)
self.end_headers()
httpd = HTTPServer(('', 8080), SimpleHTTPRequestHandler)
httpd.serve_forever()
Page 276
import network
import socket
from machine import Pin, Timer
from time import sleep_ms
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
wifi=setup(country, ssid, key)
print("Connected")
url = "http://192.168.253.72:8080"
ai = socket.getaddrinfo("www.example.com", 80,socket.AF_INET)
addr = ai[0][-1]
s = socket.socket(socket.AF_INET)
s.connect(addr)
request = b"GET /index.html HTTP/1.1\r\nHost:example.org\r\n\r\n"
s.send(request)
print(s.recv(512))
Page 277
import network
import socket
import ssl
from machine import Pin, Timer
from time import sleep_ms
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
wifi=setup(country, ssid, key)
print("Connected")
ai = socket.getaddrinfo("example.com", 443,socket.AF_INET)
addr = ai[0][-1]
s = socket.socket(socket.AF_INET)
s.connect(addr)
sslSock=ssl.wrap_socket(s)
request = b"GET / HTTP/1.1\r\nHost:example.com\r\n\r\n"
sslSock.write(request)
print(sslSock.read(1024))
Page 281
import network
import socket
from time import sleep_ms
from machine import Pin, Timer
import onewire
import ds18x20
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
wifi = setup("country", "ssid", "key")
ow = onewire.OneWire(Pin(22))
presence = ow.reset()
if presence:
print("Device present")
else:
print("No device")
DS = ds18x20.DS18X20(ow)
roms = DS.scan()
template = """<!DOCTYPE html>
<html>
<head> <title>Temperature</title> </head>
<body> <h1>Current Temperature</h1>
Hello ESP32 Server World <br/>
The Temperature is: <!--#temp--><br/>
</body>
</html>
"""
addr = socket.getaddrinfo('192.168.253.24', 8080)[0][-1]
print(addr)
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(addr)
s.listen(0)
while True:
cl, addr = s.accept()
print('client connected from', addr)
print(cl.recv(512))
DS.convert_temp()
temp = DS.read_temp(roms[0])
html=template.replace("<!--#temp-->",str(temp))
headers = ("HTTP/1.1 200 OK\r\n"
"Content-Type: text/html; charset=UTF-8\r\n"
"Server:ESP32\r\n"
f"Content-Length:{len(html)}\r\n\r\n"
)
buf = headers.encode("utf-8")+html.encode("utf-8")
cl.send(buf)
cl.close()
s.close()
Page 283
import binascii
with open("iopress.key", 'rb') as f:
lines = f.readlines()
lines = b"".join(lines[1:-1])
key = binascii.a2b_base64(lines)
print("key=", key)
with open("iopress.crt", 'rb') as f:
lines = f.readlines()
lines = b"".join(lines[1:-1])
cert = binascii.a2b_base64(lines)
print()
print("cert=", cert)
Page 284
import network
import socket
from time import sleep_ms
from machine import Pin, Timer
import onewire
import ds18x20
import ssl
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
wifi=setup(country, ssid, key)
print("Connected")
print(wifi.ifconfig())
key=b'0\x82\x04\xbf\ . . .xabp\xd1'
cert=b'0\x82\x03k0\ . . .\x98\x8a'
ow = onewire.OneWire(Pin(22))
presence = ow.reset()
if presence:
print("Device present")
else:
print("No device")
DS = ds18x20.DS18X20(ow)
roms = DS.scan()
template = """<!DOCTYPE html>
<html>
<head> <title>Temperature</title> </head>
<body> <h1>Current Temperature</h1>
Hello ESP32 Server World <br/>
The Temperature is: <!--#temp--><br/>
</body>
</html>
"""
addr = socket.getaddrinfo('0.0.0.0', 443)[0][-1]
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(addr)
s.listen(5)
while True:
cl, addr = s.accept()
print('client connected from', addr)
client_s =None
try:
client_s = ssl.wrap_socket(cl, server_side=True,
key=key, cert=cert)
while True:
h = client_s.readline()
if h == b"" or h == b"\r\n":
break
print(h.decode(), end="")
DS.convert_temp()
temp = DS.read_temp(roms[0])
html=template.replace("<!--#temp-->",str(temp))
headers = ("HTTP/1.1 200 OK\r\n"
"Content-Type: text/html; charset=UTF-8\r\n"
"Server:ESP32\r\n"
f"Content-Length:{len(html)}\r\n\r\n"
)
buf = headers.encode("utf-8")+html.encode("utf-8")
client_s.write(buf)
client_s.close()
except Exception as e:
print("exception ",e)
s.close()
Page 304
import uasyncio
from machine import Pin
async def blink(led, period_ms):
while True:
led.on()
await uasyncio.sleep_ms(5)
led.off()
await uasyncio.sleep_ms(period_ms)
async def main(led1, led2):
uasyncio.create_task(blink(led1, 700))
uasyncio.create_task(blink(led2, 400))
await uasyncio.sleep_ms(10_000)
uasyncio.run(main(Pin(22,Pin.OUT), Pin(23,Pin.OUT)))
Page 305
import uasyncio
from machine import Pin
from time import sleep_ms
async def blink(led, period_ms):
while True:
led.on()
await uasyncio.sleep_ms(5)
led.off()
await uasyncio.sleep_ms(period_ms)
async def timewaste():
while True:
sleep_ms(10)
await uasyncio.sleep_ms(0)
async def main(led1, led2):
uasyncio.create_task(blink(led1, 700))
uasyncio.create_task(blink(led2, 400))
uasyncio.create_task(timewaste())
await uasyncio.sleep_ms(10_000)
uasyncio.run(main(Pin(22,Pin.OUT), Pin(23,Pin.OUT)))
Page 307
import uasyncio
from time import sleep_ms
from machine import Pin, Timer
import network
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
async def main():
reader,writer= await uasyncio.open_connection("www.example.com",80)
request = b"GET /index.html HTTP/1.1\r\nHost:example.org\r\n\r\n"
writer.write(request)
await writer.drain()
print(await reader.read(512))
reader.close()
wifi=setup(country, ssid, key)
print("Connected")
print(wifi.ifconfig())
uasyncio.run(main())
Page 310
import uasyncio
import network
from machine import Pin, Timer
from time import sleep_ms
import onewire
import ds18x20
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
wifi=setup(country, ssid, key)
print("Connected")
print(wifi.ifconfig())
ow = onewire.OneWire(Pin(22))
presence = ow.reset()
if presence:
print("Device present")
else:
print("No device")
DS = ds18x20.DS18X20(ow)
roms = DS.scan()
template = """<!DOCTYPE html>
<html>
<head> <title>Temperature</title> </head>
<body> <h1>Current Temperature</h1>
Hello ESP32 Server World <br/>
The Temperature is: <!--#temp--><br/>
</body>
</html>
"""
async def serve_client(reader,writer):
print("client")
print(await reader.read(512))
DS.convert_temp()
temp = DS.read_temp(roms[0])
html=template.replace("<!--#temp-->",str(temp))
headers = ("HTTP/1.1 200 OK\r\n"
"Content-Type: text/html; charset=UTF-8\r\n"
"Server:ESP32\r\n"
f"Content-Length:{len(html)}\r\n\r\n"
)
buf = headers.encode("utf-8")+html.encode("utf-8")
writer.write(buf)
await writer.drain()
writer.close()
await writer.wait_closed()
async def main():
await uasyncio.start_server(serve_client, '192.168.253.24', 80,backlog=5)
while True:
print("heartbeat")
await uasyncio.sleep(1)
uasyncio.run(main())
Page 315
from machine import mem32,Pin
from time import sleep_ms
led = Pin(2,mode=Pin.OUT)
GPIOSet = 0x3FF44008
GPIOClear = 0x3FF4400C
mask = 1<<2
while True:
mem32[GPIOSet] = mask
sleep_ms(500)
mem32[GPIOClear] = mask
sleep_ms(500)
Page 315
from machine import mem32,Pin
from time import sleep_ms
@micropython.native
def blink():
GPIOSet = 0x3FF44008
GPIOClear = 0x3FF4400C
mask = 1<<2
while True:
mem32[GPIOSet] = mask
mem32[GPIOClear] = mask
led = Pin(2,mode=Pin.OUT)
blink()
Page 318
from machine import Pin
import machine
def gpio_setgroup(value, mask):
machine.mem32[0x3FF44004] = machine.mem32[0x3FF44004] & ~mask | value & mask
pin = Pin(2, Pin.OUT)
pin = Pin(4, Pin.OUT)
value1 = 1 << 2 | 0 << 4
value2 = 0 << 2 | 1 << 4
mask = 1 << 2 | 1 << 4
while True:
gpio_setgroup(value1, mask)
gpio_setgroup(value2, mask)
Page 323
from machine import Pin, DAC, mem32
from time import sleep
def _reg_get(adr):
return mem32[adr]
def _reg_set( adr,value, mask):
mem32[adr] = mem32[adr] & ~mask | value & mask
def enableSin(chan,f):
if chan<1 or chan>2:
return
setFreq(chan, f)
setPhase(chan,0x2)
#enable tone
_reg_set(0x3FF48898, 0x10000, 0x10000)
#select caannel
if chan==1:
_reg_set(0x3FF4889c, 1<<24,0x1<<24)
else:
_reg_set(0x3FF4889c, 1<<25, 0x1 <<25)
def setFreq(chan,f):
if chan<1 or chan>2:
return
step = int(f*65536/8000000) & 0xFFFF
_reg_set(0x3FF48898, step, 0x000FF)
def setPhase(chan,p):
_reg_set(0x3FF4889c, p << (20 + 2 * (chan – 1)), 0x03 << (20 + 2 * (chan - 1)))
def setScale(chan,s):
_reg_set(0x3FF4889c, s << (16 + 2 * (chan - 1)),0x03 << (16 + 2 * (chan - 1)))
def setOff(chan,off):
_reg_set(0x3FF4889c, off << (8 * (chan - 1)),0xFF << (8 * (chan - 1)))
dac1 = DAC(Pin(26))
enableSin(2,30000)
setScale(2,0x0)
setOff(2,0x0)
while(True):
sleep(0.001)
setPhase(2,0x3)
sleep(.001)
setPhase(2, 0x2)
Page 324
import ntptime
from machine import RTC
import network
from machine import Pin, Timer
from time import sleep_ms
def setup(country, ssid, key):
network.country(country)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.disconnect()
LED = Pin(2, Pin.OUT)
LED.on()
timeout = 20000
wifi.connect(ssid,key)
timer = Timer(1)
timer.init(period=200, mode=Timer.PERIODIC,callback=lambda t:LED.value(not LED.value()))
s = network.STAT_IDLE
while timeout>0:
print("connecting",s)
s = wifi.status()
if s != network.STAT_CONNECTING:
break
sleep_ms(100)
timeout = timeout-100
if(s==network.STAT_GOT_IP):
timer.init(period=1000, mode=Timer.PERIODIC, callback=lambda t:LED.value(not LED.value()))
else:
timer.deinit()
LED.on()
return wifi
wifi=setup(country, ssid, key)
print("Connected")
print(wifi.ifconfig())
ntptime.host="pool.ntp.org"
ntptime.timeout=1000
try:
ntptime.settime()
except Exception:
print("NTP server not available")
pass
rtc = RTC()
print(rtc.datetime())
Page 326
from machine import lightsleep
from time import sleep
for i in range(10):
print("starting sleep",i)
lightsleep(1000)
print ("back from sleep",i)
Page 327
from machine import deepsleep
from time import sleep
for i in range(10):
print("starting sleep",i)
sleep(2)
print('I am going to sleep')
deepsleep(1000)
Page 327
from machine import deepsleep, RTC
from time import sleep
sleep(3)
rtc = RTC()
if len(rtc.memory())==0:
start=0
else:
start = int.from_bytes(rtc.memory(),"big")
for i in range(start,start+10):
print(i)
print("starting sleep")
rtc.memory((i+1).to_bytes(4,"big"))
deepsleep(1000)
Page 329
from machine import lightsleep,Pin
import esp32
wakePin = Pin(2,Pin.IN,pull=None)
esp32.wake_on_ext0(wakePin,esp32.WAKEUP_ANY_HIGH)
for i in range(10):
print("starting sleep",i)
lightsleep()
print ("back from sleep",i)
Page 331
from machine import WDT
from time import sleep
sleep(4)
print("starting")
wdt = WDT(timeout=4000)
wdt.feed()
while True:
sleep(0.1)
print("still running")
pass
Page 336
from machine import deepsleep
from time import sleep
from esp32 import NVS
sleep(3)
start = 0
nvsState = NVS("state")
try:
start = nvsState.get_i32("start")
except OSError:
pass
for i in range(start,start+10):
print(i)
print("starting sleep")
nvsState.set_i32("start",i+1)
nvsState.commit()
deepsleep(1000)
Page 3 of 5
- You are here:
-
Home
- Programs
