{"id":83432,"date":"2024-06-24T14:00:57","date_gmt":"2024-06-24T12:00:57","guid":{"rendered":"https:\/\/botland.com.pl\/blog\/kurs-raspberry-pi-pico-10-tablice-struktury-i-maszyna-stanow\/"},"modified":"2026-04-08T10:55:36","modified_gmt":"2026-04-08T08:55:36","slug":"raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten","status":"publish","type":"post","link":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/","title":{"rendered":"Raspberry Pi Pico Kurs &#8211; #10 &#8211; Arrays, Strukturen und Zustandsautomaten"},"content":{"rendered":"<span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Lesezeit<\/span> <span class=\"rt-time\"> 19<\/span> <span class=\"rt-label rt-postfix\">min.<\/span><\/span>\t\t<div data-elementor-type=\"wp-post\" data-elementor-id=\"83432\" class=\"elementor elementor-83432 elementor-82752\" data-elementor-post-type=\"post\">\n\t\t\t\t\t\t<section class=\"elementor-section elementor-top-section elementor-element elementor-element-20bcf6e elementor-section-boxed elementor-section-height-default elementor-section-height-default\" data-id=\"20bcf6e\" data-element_type=\"section\" data-e-type=\"section\">\n\t\t\t\t\t\t<div class=\"elementor-container elementor-column-gap-default\">\n\t\t\t\t\t<div class=\"elementor-column elementor-col-100 elementor-top-column elementor-element elementor-element-45eb4ed\" data-id=\"45eb4ed\" data-element_type=\"column\" data-e-type=\"column\">\n\t\t\t<div class=\"elementor-widget-wrap elementor-element-populated\">\n\t\t\t\t\t\t<div class=\"elementor-element elementor-element-25befc4 elementor-widget elementor-widget-text-editor\" data-id=\"25befc4\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Im letzten Tutorial haben wir gemeinsam das inzwischen wohlbekannte blink led-Projekt gestartet, das jedoch keine CPU-blockierende sleep_ms-Funktion enthielt. Au\u00dferdem haben wir zum ersten Mal Indikatoren und eine Struktur verwendet, die wir, wie versprochen, in diesem Artikel behandeln werden. Au\u00dferdem erkl\u00e4re ich Ihnen, wie Sie Zustandsautomaten in der Sprache C erstellen k\u00f6nnen.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-0c30471 elementor-widget elementor-widget-image\" data-id=\"0c30471\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/05\/4Gotowy-Zestaw-do-nauki-programowania-z-Raspberry-Pi-Pico-W.jpg\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"4Gotowy-Zestaw-do-nauki-programowania-z-Raspberry-Pi-Pico-W\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODMzMzQsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNVwvNEdvdG93eS1aZXN0YXctZG8tbmF1a2ktcHJvZ3JhbW93YW5pYS16LVJhc3BiZXJyeS1QaS1QaWNvLVcuanBnIn0%3D\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img fetchpriority=\"high\" decoding=\"async\" width=\"800\" height=\"109\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/05\/4Gotowy-Zestaw-do-nauki-programowania-z-Raspberry-Pi-Pico-W-1024x139.jpg\" class=\"attachment-large size-large wp-image-83334\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/05\/4Gotowy-Zestaw-do-nauki-programowania-z-Raspberry-Pi-Pico-W-1024x139.jpg 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/05\/4Gotowy-Zestaw-do-nauki-programowania-z-Raspberry-Pi-Pico-W-300x41.jpg 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/05\/4Gotowy-Zestaw-do-nauki-programowania-z-Raspberry-Pi-Pico-W-768x104.jpg 768w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/05\/4Gotowy-Zestaw-do-nauki-programowania-z-Raspberry-Pi-Pico-W.jpg 1429w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<section class=\"elementor-section elementor-inner-section elementor-element elementor-element-45ccf87 elementor-section-boxed elementor-section-height-default elementor-section-height-default\" data-id=\"45ccf87\" data-element_type=\"section\" data-e-type=\"section\">\n\t\t\t\t\t\t<div class=\"elementor-container elementor-column-gap-default\">\n\t\t\t\t\t<div class=\"elementor-column elementor-col-50 elementor-inner-column elementor-element elementor-element-bd40b19\" data-id=\"bd40b19\" data-element_type=\"column\" data-e-type=\"column\">\n\t\t\t<div class=\"elementor-widget-wrap elementor-element-populated\">\n\t\t\t\t\t\t<div class=\"elementor-element elementor-element-be82da3 elementor-widget elementor-widget-image\" data-id=\"be82da3\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/01\/24136_3.jpg\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"24136_3\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6NzYxNjMsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wMVwvMjQxMzZfMy5qcGcifQ%3D%3D\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img decoding=\"async\" width=\"300\" height=\"273\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/24136_3-300x273.jpg\" class=\"attachment-medium size-medium wp-image-76163\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/24136_3-300x273.jpg 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/24136_3-1024x933.jpg 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/24136_3-768x700.jpg 768w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/24136_3.jpg 1080w\" sizes=\"(max-width: 300px) 100vw, 300px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t<div class=\"elementor-column elementor-col-50 elementor-inner-column elementor-element elementor-element-0e6eadf\" data-id=\"0e6eadf\" data-element_type=\"column\" data-e-type=\"column\">\n\t\t\t<div class=\"elementor-widget-wrap elementor-element-populated\">\n\t\t\t\t\t\t<div class=\"elementor-element elementor-element-c1a1e6a elementor-widget elementor-widget-text-editor\" data-id=\"c1a1e6a\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p><span style=\"font-weight: bolder;\">Kaufen Sie ein Set, um das Programmieren mit dem Raspberry Pi Pico W zu erlernen, und nutzen Sie die Vorteile des Kurses, der im Botland Blog verf\u00fcgbar ist!<\/span><\/p>\n<p>Im Set enthalten: Raspberry Pi Pico W-Modul, Kontaktplatte, Leitungen, LEDs, Widerst\u00e4nde, Tasten, Fotowiderst\u00e4nde, digitale Licht-, Temperatur-, Feuchtigkeits- und Drucksensoren, OLED-Display und ein USB-microUSB-Kabel.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-1741779 elementor-align-center elementor-widget elementor-widget-button\" data-id=\"1741779\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"button.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<div class=\"elementor-button-wrapper\">\n\t\t\t\t\t<a class=\"elementor-button elementor-button-link elementor-size-sm\" href=\"https:\/\/botland.de\/module-und-sets-fuer-raspberry-pi-pico\/24136-programmieren-lernen-mit-dem-raspberry-pi-pico-w-kit.html\" target=\"_blank\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t<span class=\"elementor-button-content-wrapper\">\n\t\t\t\t\t\t\t\t\t<span class=\"elementor-button-text\">BEI BOTLAND NACHSEHEN<\/span>\n\t\t\t\t\t<\/span>\n\t\t\t\t\t<\/a>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t<div class=\"elementor-element elementor-element-83366bf elementor-widget-divider--view-line elementor-widget elementor-widget-divider\" data-id=\"83366bf\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"divider.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"elementor-divider\">\n\t\t\t<span class=\"elementor-divider-separator\">\n\t\t\t\t\t\t<\/span>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-5bac091 elementor-widget elementor-widget-text-editor\" data-id=\"5bac091\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p><span style=\"font-weight: bolder;\">Inhaltsverzeichnis:<\/span><\/p>\n<ol style=\"font-size: 16px; background-color: #ffffff;\">\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-1-einstieg\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">Raspberry Pi Pico &#8211; #1<\/span> &#8211; Einstieg <\/a><\/li>\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-2-ein-paar-worte-zur-programmierung\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">Raspberry Pi Pico &#8211; #2<\/span> &#8211; ein paar Worte zur Programmierung<\/a><\/li>\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-3-erstes-programm\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">Raspberry Pi Pico &#8211; #3<\/span> &#8211; erstes Programm<\/a><\/li>\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-4-erste-schritte-in-der-programmierung\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">Raspberry Pi Pico &#8211; #4<\/span> &#8211; wir beginnen mit der Programmierung<\/a><\/li>\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-5-schleifen-variablen-und-bedingte-anweisungen\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">Raspberry Pi Pico &#8211; #5<\/span> &#8211; Schleifen, Variablen und bedingte Anweisungen <\/a><\/li>\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-6-pwm-adc-und-kommunikation-mit-dem-computer\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">Raspberry Pi Pico &#8211; #6<\/span> &#8211; PWM, ADC und Kommunikation mit dem Computer<\/a><\/li>\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-7-code-korrekturen-und-eigene-funktionen\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">Raspberry Pi Pico &#8211; #7<\/span> &#8211; Codekorrekturen und eigene Funktionen <\/a><\/li>\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-8-unterbrechungen-und-alarme\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">Raspberry Pi Pico &#8211; #8<\/span> &#8211; Unterbrechungen und Alarme<\/a><\/li>\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-9-indikatorentheorie-und-timer\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">Raspberry Pi Pico &#8211; #9<\/span> &#8211; Indikatorentheorie und Timer<\/a><\/li>\n<li style=\"font-size: 16px;\"><a href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><strong>Raspberry Pi Pico &#8211; #10<\/strong> &#8211; Arrays, Strukturen und Zustandsautomaten<\/a><\/li>\n<\/ol>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-55e404b elementor-widget elementor-widget-spacer\" data-id=\"55e404b\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"spacer.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"elementor-spacer\">\n\t\t\t<div class=\"elementor-spacer-inner\"><\/div>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-bebde58 elementor-widget elementor-widget-heading\" data-id=\"bebde58\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">Vor dem Start sollte das Team zusammengestellt werden<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-507f3f0 elementor-widget elementor-widget-image\" data-id=\"507f3f0\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/01\/IMG_0647-scaled.jpg\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"IMG_0647\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6NzQ4MDAsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wMVwvSU1HXzA2NDctc2NhbGVkLmpwZyJ9\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img decoding=\"async\" width=\"800\" height=\"450\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/IMG_0647-1024x576.jpg\" class=\"attachment-large size-large wp-image-74800\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/IMG_0647-1024x576.jpg 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/IMG_0647-300x169.jpg 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/IMG_0647-768x432.jpg 768w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/IMG_0647-1536x864.jpg 1536w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/01\/IMG_0647-2048x1152.jpg 2048w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Ein Satz von Komponenten f\u00fcr den Raspberry Pi Pico Kurs.<\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-0d642c6 elementor-align-center elementor-widget elementor-widget-button\" data-id=\"0d642c6\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"button.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<div class=\"elementor-button-wrapper\">\n\t\t\t\t\t<a class=\"elementor-button elementor-button-link elementor-size-sm\" href=\"https:\/\/botland.de\/module-und-sets-fuer-raspberry-pi-pico\/24136-programmieren-lernen-mit-dem-raspberry-pi-pico-w-kit.html\" target=\"_blank\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t<span class=\"elementor-button-content-wrapper\">\n\t\t\t\t\t\t\t\t\t<span class=\"elementor-button-text\">SIEHE HIER<\/span>\n\t\t\t\t\t<\/span>\n\t\t\t\t\t<\/a>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-110cfc2 elementor-widget elementor-widget-text-editor\" data-id=\"110cfc2\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>Wer das Programmieren anhand von realen Projekten erlernen m\u00f6chte, braucht nat\u00fcrlich die richtige Ausr\u00fcstung, aber keine Sorge &#8211; Sie m\u00fcssen jetzt nicht von einem Artikel zum n\u00e4chsten springen und eine Liste der ben\u00f6tigten elektronischen Komponenten erstellen. Im <a style=\"background-color: #ffffff;\" href=\"https:\/\/botland.de\" target=\"_blank\" rel=\"noopener nofollow external noreferrer\" data-wpel-link=\"external\"><span style=\"font-weight: bolder;\">Botland<\/span><\/a>-Shop ist ein <a style=\"background-color: #ffffff;\" href=\"https:\/\/botland.de\/module-und-sets-fuer-raspberry-pi-pico\/24136-programmieren-lernen-mit-dem-raspberry-pi-pico-w-kit.html\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">fertiges Set<\/span><\/a> erh\u00e4ltlich, das alle notwendigen Komponenten enth\u00e4lt, um die in der Tutorial-Reihe beschriebenen Projekte mit dem Raspberry Pi Pico durchzuf\u00fchren. <\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-7b5b618 elementor-widget elementor-widget-text-editor\" data-id=\"7b5b618\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>In dem <a href=\"https:\/\/botland.de\/module-und-sets-fuer-raspberry-pi-pico\/24136-programmieren-lernen-mit-dem-raspberry-pi-pico-w-kit.html\" target=\"_blank\" rel=\"noopener\" data-wpel-link=\"internal\"><span style=\"font-weight: bolder;\">fertigen Set<\/span><\/a> von Elementen finden Sie:<\/p>\n<ul style=\"font-size: 16px; background-color: #ffffff;\">\n<li style=\"font-size: 16px;\">Raspberry Pi Pico W,<\/li>\n<li style=\"font-size: 16px;\">MicroUSB-Kabel,<\/li>\n<li style=\"font-size: 16px;\">Kontaktplatte,<\/li>\n<li style=\"font-size: 16px;\">Ein Set von Anschlusskabeln in drei Ausf\u00fchrungen,<\/li>\n<li style=\"font-size: 16px;\">Ein Set von LEDs in drei Farben,<\/li>\n<li style=\"font-size: 16px;\">Ein Set der in der Elektronik am h\u00e4ufigsten verwendeten Widerst\u00e4nde,<\/li>\n<li style=\"font-size: 16px;\">Tact Switch-Tasten,<\/li>\n<li style=\"font-size: 16px;\">Fotowiderst\u00e4nde,<\/li>\n<li style=\"font-size: 16px;\">Digitaler Lichtsensor,<\/li>\n<li style=\"font-size: 16px;\">Digitaler Feuchtigkeits-, Temperatur- und Drucksensor,<\/li>\n<li style=\"font-size: 16px;\">OLED-Display.<\/li>\n<\/ul>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-16cea8f elementor-widget elementor-widget-spacer\" data-id=\"16cea8f\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"spacer.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"elementor-spacer\">\n\t\t\t<div class=\"elementor-spacer-inner\"><\/div>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-d97ec8b elementor-widget elementor-widget-heading\" data-id=\"d97ec8b\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">Einzelne und mehrdimensionale Arrays<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-896be1d elementor-widget elementor-widget-text-editor\" data-id=\"896be1d\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Zun\u00e4chst w\u00e4re es sinnvoll, auf das Thema der Strukturen zur\u00fcckzukommen, das bereits bei dem k\u00fcrzlich diskutierten Projekt zur Sprache kam. Bevor wir jedoch weitermachen, werden wir versuchen, einen Code auszuf\u00fchren, der auf etwas einfacheren Konstrukten basiert, n\u00e4mlich Arrays.<\/p>\n<p style=\"font-weight: 400\">Bisher haben wir ganz allgemein verschiedene Arten von Variablen verwendet; sie k\u00f6nnen ganze Zahlen, Flie\u00dfkommazahlen und logische Zust\u00e4nde speichern. Es ist jedoch erw\u00e4hnenswert, dass eine einzelne Variable nur einen einzigen Wert speichern kann. Wenn wir die Temperatur vom eingebauten Sensor des RP2040 ablesen, wird immer der letzte Wert in der Variable gespeichert und es gibt keine M\u00f6glichkeit, ihn mit einer fr\u00fcheren Messung zu vergleichen.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-4b4374c elementor-widget elementor-widget-image\" data-id=\"4b4374c\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/zmienna_tablica.png\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"zmienna_tablica\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODI3ODgsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvem1pZW5uYV90YWJsaWNhLnBuZyJ9\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"520\" height=\"295\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/zmienna_tablica.png\" class=\"attachment-large size-large wp-image-82788\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/zmienna_tablica.png 520w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/zmienna_tablica-300x170.png 300w\" sizes=\"(max-width: 520px) 100vw, 520px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Ein Vergleich von Variablen und Arrays.<\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-e552fc7 elementor-widget elementor-widget-text-editor\" data-id=\"e552fc7\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Wenn wir davon ausgehen, dass eine einzelne Variable ein Blatt Papier sein k\u00f6nnte, auf dem der geschriebene Text sein Wert ist, dann k\u00f6nnte ein Array ein Buch sein. Mit anderen Worten: Arrays in C sind Sammlungen von Variablen desselben Typs, deren Wert variieren kann. Die Verwendung von Arrays kann sehr n\u00fctzlich sein, insbesondere wenn wir viele Werte desselben Typs speichern m\u00fcssen. Die Deklaration einzelner Variablen ist in einem solchen Fall einfach unn\u00f6tig und verkompliziert den Code unn\u00f6tig. Dar\u00fcber hinaus k\u00f6nnen mit Arrays so genannte Puffer erstellt werden, die f\u00fcr verschiedene Arten der Kommunikation besonders n\u00fctzlich sind, sowie Zeichenfolgen von Text, so genannte Strings (von dem englischen Wort string). Es sollte auch erw\u00e4hnt werden, dass Arrays mehrere Dimensionen haben k\u00f6nnen, aber mit diesem Thema werden wir uns gleich besch\u00e4ftigen. Nehmen wir als ersten Schritt ein einfaches Programm, das ein eindimensionales Array verwendet.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-b7d4a8d elementor-widget elementor-widget-image\" data-id=\"b7d4a8d\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/obwod-scaled.jpg\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"obwod\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODI3OTIsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvb2J3b2Qtc2NhbGVkLmpwZyJ9\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"800\" height=\"450\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/obwod-1024x576.jpg\" class=\"attachment-large size-large wp-image-82792\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/obwod-1024x576.jpg 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/obwod-300x169.jpg 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/obwod-768x432.jpg 768w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/obwod-1536x864.jpg 1536w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/obwod-2048x1152.jpg 2048w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Ein Schaltkreis, der aus fr\u00fcheren Ratgebern bekannt ist.<\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-0ef93d0 elementor-widget elementor-widget-text-editor\" data-id=\"0ef93d0\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">An diesem Punkt brauchen wir die vorbereitete Schaltung nicht zu \u00e4ndern. Im ersten Projekt, das ich als arrays_test beschrieben habe, werden wir die LEDs steuern. Dieses Mal bestimmt jedoch der im Array gespeicherte Wert, ob die Diode ausgel\u00f6st wird oder nicht. Au\u00dferdem werden wir versuchen, einen bestimmten Wert im Array zu \u00e4ndern, also gehen wir zum ersten Programm \u00fcber.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-f70201c elementor-widget elementor-widget-code-highlight\" data-id=\"f70201c\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"prismjs-okaidia copy-to-clipboard word-wrap\">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-c line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-c\">\n\t\t\t\t\t<xmp>#include \"pico\/stdlib.h\"\r\n\r\n#define GREEN_LED 0\r\n#define YELLOW_LED 1\r\n#define RED_LED 2\r\n\r\nbool led_state_array[3] = {1, 0, 1}; \/\/ array declaration\r\n\r\nint main() {\r\n    stdio_init_all(); \/\/initialization of the stdio.h library\r\n\r\n    gpio_init(GREEN_LED);\r\n    gpio_init(YELLOW_LED);\r\n    gpio_init(RED_LED);\r\n    gpio_set_dir(GREEN_LED, GPIO_OUT);\r\n    gpio_set_dir(YELLOW_LED, GPIO_OUT);\r\n    gpio_set_dir(RED_LED, GPIO_OUT);\r\n\r\n    while(true) {\r\n\r\n            gpio_put(GREEN_LED, led_state_array[0]);\r\n            gpio_put(YELLOW_LED, led_state_array[1]);\r\n            gpio_put(RED_LED, led_state_array[2]);\r\n\r\n            sleep_ms(3000);\r\n\r\n            led_state_array[0] = 0; \/\/ changing the value of an element with index zero\r\n\r\n    }\r\n}\r\n<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-e84bc86 elementor-widget elementor-widget-text-editor\" data-id=\"e84bc86\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\"> Die Struktur des Codes ist eigentlich recht einfach. Hier haben wir die Standardbibliothek eingebunden, die Definition der Pins, an die die LEDs angeschlossen sind, die dann am Anfang der Hauptfunktion main initialisiert werden. Die ganze Magie im Zusammenhang mit Arrays geschieht innerhalb der Endlosschleife und oberhalb der Hauptfunktion.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-9e20294 elementor-widget elementor-widget-image\" data-id=\"9e20294\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/Typ-danych-1024x576-2.jpg\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"Typ-danych-1024x576\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODM2MzgsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvVHlwLWRhbnljaC0xMDI0eDU3Ni0yLmpwZyJ9\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"800\" height=\"450\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/Typ-danych-1024x576-2.jpg\" class=\"attachment-large size-large wp-image-83638\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/Typ-danych-1024x576-2.jpg 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/Typ-danych-1024x576-2-300x169.jpg 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/Typ-danych-1024x576-2-768x432.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Erkl\u00e4rung der Arrays.<\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-d04d980 elementor-widget elementor-widget-text-editor\" data-id=\"d04d980\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Wenden wir uns zun\u00e4chst der Erkl\u00e4rung des Arrays selbst zu. Es sieht dem Code, der eine Variable zum Leben erweckt, sehr \u00e4hnlich. Hier k\u00f6nnen wir auch den Typ des Arrays unterscheiden, genauer gesagt den Typ der Daten, die sich in dem Array befinden werden. In unserem Beispiel ist es bool, da wir logische Werte speichern werden, die dem Zustand entsprechen, in dem sich die LED befindet. Als N\u00e4chstes folgt der Name des Arrays, hier ist es einfach led_state_array. In eckige Klammern setzen wir die Zahl, die der Anzahl der Elemente im Array entspricht. Wir werden drei Dioden ansteuern, deshalb habe ich hier die Zahl drei eingesetzt. Wichtig ist, dass wir bei der Deklaration eines Arrays die Gr\u00f6\u00dfe des Arrays nicht angeben m\u00fcssen. Die eckige Klammer kann leer gelassen werden und der Compiler w\u00fcrde die Anzahl der sp\u00e4ter deklarierten Elemente selbst \u00fcberpr\u00fcfen. Nach dem Gleichheitszeichen werden die Standardwerte aller Elemente im Array in geschweifte Klammern gesetzt. Jedes wird mit dem Index [0], [1] und [2] bezeichnet. Wichtig ist, dass der Indexwert von links nach rechts ansteigt. Das kann kontraintuitiv sein, insbesondere f\u00fcr diejenigen, die sich mit digitaler Elektronik besch\u00e4ftigt haben, bei der das j\u00fcngste Bit mit einem Null-Index normalerweise ganz rechts platziert wird.<\/p>\n<p style=\"font-weight: 400;\">Das so deklarierte Array speichert drei Variablen vom Typ bool, deren Werte wir bereits zu Beginn angegeben haben.<\/p>\n<p style=\"font-weight: 400;\">In der while-Schleife sehen wir drei Funktionen, die aufeinanderfolgende LEDs steuern. In diesem Fall bestimmen wir den Zustand der leuchtenden Struktur durch ein bestimmtes Element des Arrays, indem wir dessen Namen und Index in eckigen Klammern angeben. So entspricht der Zustand der gr\u00fcnen LED dem ersten Element im Array, die gelbe LED nimmt den Zustand des zweiten Elements an und der roten LED wird der Wert des letzten Elements im Array zugewiesen. Wie Sie sich denken k\u00f6nnen, sollten beim Starten des Programms die beiden \u00e4u\u00dfersten LEDs aufleuchten, d.h. gr\u00fcn und rot.<\/p>\n<p style=\"font-weight: 400;\">Der Einfachheit halber werden wir jedoch den Wert des ersten Elements im Array \u00e4ndern, nachdem wir drei Sekunden gewartet haben. Der Verweis darauf ist identisch mit dem in der LED-Steuerungsfunktion. Zuerst geben wir den Namen des Arrays an und in eckigen Klammern den Index des entsprechenden Elements. Wie bei Variablen weisen wir dank des Gleichheitszeichens einen Wert von Null zu.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-6a96197 elementor-widget elementor-widget-video\" data-id=\"6a96197\" data-element_type=\"widget\" data-e-type=\"widget\" data-settings=\"{&quot;video_type&quot;:&quot;hosted&quot;,&quot;controls&quot;:&quot;yes&quot;}\" data-widget_type=\"video.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"e-hosted-video elementor-wrapper elementor-open-inline\">\n\t\t\t\t\t<video class=\"elementor-video\" src=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/tab1.mov\" controls=\"\" preload=\"metadata\" controlsList=\"nodownload\"><\/video>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-dc63b92 elementor-widget elementor-widget-text-editor\" data-id=\"dc63b92\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Nachdem wir das Programm ausgef\u00fchrt haben, k\u00f6nnen wir den erwarteten Effekt sehen. Im ersten Schritt wurden die beiden \u00e4u\u00dfersten LEDs &#8211; gr\u00fcn und rot &#8211; aktiviert. Anschlie\u00dfend, nach einer Wartezeit von drei Sekunden, \u00e4nderte der Mikrocontroller das erste Element im Array und kehrte an den Anfang der while-Schleife zur\u00fcck, um die LEDs erneut anzusteuern. Auf diese Weise wurde das gr\u00fcne Lichtelement ausgeschaltet, da sein Zustand durch das Element im Array mit dem Index Null beschrieben wurde.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-789994d elementor-widget elementor-widget-image\" data-id=\"789994d\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/tablica3d-1024x576-1.jpg\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"tablica3d-1024x576\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODM2NDIsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvdGFibGljYTNkLTEwMjR4NTc2LTEuanBnIn0%3D\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"800\" height=\"450\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/tablica3d-1024x576-1.jpg\" class=\"attachment-large size-large wp-image-83642\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/tablica3d-1024x576-1.jpg 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/tablica3d-1024x576-1-300x169.jpg 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/tablica3d-1024x576-1-768x432.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Deklaration eines zweidimensionalen Arrays. <\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-07c1c9f elementor-widget elementor-widget-text-editor\" data-id=\"07c1c9f\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Im ersten Beispiel haben wir ein eindimensionales Array verwendet. Nachfolgende Daten darin wurden durch einen einzelnen Index beschrieben, aber es ist wissenswert, dass auch mehrdimensionale Arrays in C erstellt werden k\u00f6nnen, und das ist der Fall, den wir dieses Mal untersuchen werden. Doch bevor wir uns dem Programm zuwenden, lassen Sie uns anhand des Beispiels, das wir gleich verwenden werden, sehen, wie Arrays dieses Typs deklariert werden.<\/p>\n<p style=\"font-weight: 400;\">Im Vergleich zur letzten Einsetzung des Arrays ist die Struktur dieses Befehls leicht erweitert worden. Beachten Sie zun\u00e4chst, dass auf den Namen des Arrays zwei eckige Klammern folgen, in denen wir die Dimensionen des Arrays angeben, also die Anzahl der Zeilen und Spalten. In unserem Programm werden wir immer noch drei LEDs ansteuern, also wird das Board drei Spalten haben. Die Anzahl der Zeilen wird dagegen acht betragen, um alle m\u00f6glichen Zust\u00e4nde der drei Elemente zu nutzen. Wenn Sie sich die Zust\u00e4nde ansehen, werden Sie in den folgenden Zeilen des Arrays feststellen, dass sie fortlaufenden Zahlen im Bin\u00e4rcode entsprechen. In einem auf diese Weise vorbereiteten Array wird jedes Element durch seinen eigenen Index beschrieben, der der Zeile und Spalte entspricht. Spalten werden, wie im vorherigen Beispiel erw\u00e4hnt, von links nach rechts angegeben, w\u00e4hrend Zeilen von oben nach unten angegeben werden.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-4f85477 elementor-widget elementor-widget-code-highlight\" data-id=\"4f85477\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"prismjs-okaidia copy-to-clipboard word-wrap\">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-c line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-c\">\n\t\t\t\t\t<xmp>#include \"pico\/stdlib.h\"\r\n\r\n#define GREEN_LED 0\r\n#define YELLOW_LED 1\r\n#define RED_LED 2\r\n\r\n\/\/ declaration of a multidimensional array\r\nbool led_state_array[8][3] = {{0, 0, 0},\r\n                              {0, 0, 1},\r\n                              {0, 1, 0},\r\n                              {0, 1, 1},\r\n                              {1, 0, 0},\r\n                              {1, 0, 1},\r\n                              {1, 1, 0},\r\n                              {1, 1, 1}};\r\n\r\nint main() {\r\n    stdio_init_all(); \/\/initialization of the stdio library\r\n\r\n    gpio_init(GREEN_LED);\r\n    gpio_init(YELLOW_LED);\r\n    gpio_init(RED_LED);\r\n    gpio_set_dir(GREEN_LED, GPIO_OUT);\r\n    gpio_set_dir(YELLOW_LED, GPIO_OUT);\r\n    gpio_set_dir(RED_LED, GPIO_OUT);\r\n\r\n    while (true) {\r\n        for (int i = 0; i &lt; 8; i++) {\r\n            \/\/ Set the diode states according to the current row of the table\r\n            gpio_put(GREEN_LED, led_state_array[i][0]);\r\n            gpio_put(YELLOW_LED, led_state_array[i][1]);\r\n            gpio_put(RED_LED, led_state_array[i][2]);\r\n\r\n            \/\/ delay\r\n            sleep_ms(1000);\r\n        }\r\n    }\r\n}\r\n<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-755c803 elementor-widget elementor-widget-text-editor\" data-id=\"755c803\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Dieses Mal wurde eine neue Array-Deklaration, die Sie bereits gesehen haben, in den zu testenden Code eingef\u00fcgt. Die unendliche while-Schleife wurde ebenfalls ge\u00e4ndert. Sie enthielt eine for-Schleife, die acht Spr\u00fcnge durchf\u00fchrte, so dass die LEDs von einem Element aus jeder aufeinanderfolgenden Zeile des Arrays angesteuert wurden. Die Schleife wird achtmal ausgef\u00fchrt, mit den Befehlen, die die Dioden darin steuern. Der Zustand jeder Diode entspricht einem Element aus dem Array, das sich bei Index [i] und [0], [1] und [2] befindet. Bei jedem weiteren Schleifendurchlauf wird das &#8220;i&#8221; durch eine andere Zahl von null bis acht ersetzt, so dass den LEDs Werte aus den folgenden Zeilen des Arrays zugewiesen werden. Dar\u00fcber hinaus wurde eine Verz\u00f6gerung von einer Sekunde in den Code eingebaut, damit \u00c4nderungen im Licht der LEDs sichtbar werden.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-429287e elementor-widget elementor-widget-video\" data-id=\"429287e\" data-element_type=\"widget\" data-e-type=\"widget\" data-settings=\"{&quot;video_type&quot;:&quot;hosted&quot;,&quot;controls&quot;:&quot;yes&quot;}\" data-widget_type=\"video.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"e-hosted-video elementor-wrapper elementor-open-inline\">\n\t\t\t\t\t<video class=\"elementor-video\" src=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/swiatla2.mov\" controls=\"\" preload=\"metadata\" controlsList=\"nodownload\"><\/video>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-a5105cf elementor-widget elementor-widget-text-editor\" data-id=\"a5105cf\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Nachdem wir den Code ausgef\u00fchrt haben, k\u00f6nnen wir die wechselnden Zust\u00e4nde der LEDs sehen. Wenn wir genauer hinsehen, k\u00f6nnen wir feststellen, dass sie mit den im Array gespeicherten Werten \u00fcbereinstimmen.<\/p>\n<p style=\"font-weight: 400\">Es ist wichtig zu wissen, dass wir in der Sprache C nicht nur zwei- und eindimensionale Arrays erstellen k\u00f6nnen, sondern dass uns nichts daran hindert, ein dreidimensionales oder sogar ein vierdimensionales Array zu initialisieren. Solche Beispiele sind jedoch schon etwas fortgeschrittener und wir werden sie hier nicht analysieren. Zwei Grundformen von Arrays werden uns f\u00fcr den Moment gen\u00fcgen.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-36bd9c4 elementor-widget elementor-widget-heading\" data-id=\"36bd9c4\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">Strukturen, oder Pseudo-Objektivit\u00e4t in C<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-32704e7 elementor-widget elementor-widget-text-editor\" data-id=\"32704e7\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Anhand von einfachen Beispielen lernten wir Arrays kennen, die als kleinere oder gr\u00f6\u00dfere Sammlungen von Variablen desselben Typs beschrieben werden k\u00f6nnen, die wir mit Hilfe von Indexen voneinander unterscheiden k\u00f6nnen. Eine Einschr\u00e4nkung bei dieser Art von Konstruktion ist jedoch der gerade erw\u00e4hnte Datentyp. In Arrays haben wir nicht die M\u00f6glichkeit, mehrere verschiedene Variablen zu speichern, die ein etwas gr\u00f6\u00dferes Objekt beschreiben w\u00fcrden. Nehmen wir f\u00fcr dieses Beispiel einen Mann, der einen Namen, ein Alter und eine Gr\u00f6\u00dfe hat. Der Vorname ist eine Zeichenfolge, das Alter ist eine ganze Zahl und die Gr\u00f6\u00dfe ist eine Zahl mit einem Komma. Solche Daten k\u00f6nnen auf keinen Fall in einem Array untergebracht werden, wir m\u00fcssten drei separate Variablen erstellen und das werden wir auch tun, aber wir werden sie in einer Struktur unterbringen. In der Sprache C gibt es eine bestimmte komplexe Konstruktion, die Struktur genannt wird. Sie erm\u00f6glicht es, verschiedene Arten von Variablen zu gruppieren und mit ihnen gr\u00f6\u00dfere Objekte zu erstellen, die viele Attribute haben, wie der oben erw\u00e4hnte Mensch. Im folgenden Beispiel werden wir eine solche Struktur zur Beschreibung einer Person erstellen, in der Informationen \u00fcber ihren Namen, ihr Alter und ihre Gr\u00f6\u00dfe gespeichert werden. Diese Daten werden, sobald sie gespeichert sind, an den Computer gesendet und auf dem Monitor der seriellen Schnittstelle angezeigt. F\u00fcr dieses Programm habe ich ein weiteres Projekt mit dem Namen struct_test erstellt, aber bevor wir uns damit befassen, sollten wir uns die Deklaration der Struktur, die wir gleich verwenden werden, genauer ansehen.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-8ab8478 elementor-widget elementor-widget-image\" data-id=\"8ab8478\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/struct-1024x576-1.jpg\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"struct-1024x576\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODM2NDksInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvc3RydWN0LTEwMjR4NTc2LTEuanBnIn0%3D\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"800\" height=\"450\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struct-1024x576-1.jpg\" class=\"attachment-large size-large wp-image-83649\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struct-1024x576-1.jpg 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struct-1024x576-1-300x169.jpg 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struct-1024x576-1-768x432.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Erkl\u00e4rung der Struktur. <\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-1e11fc1 elementor-widget elementor-widget-text-editor\" data-id=\"1e11fc1\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Wir erwecken Strukturen in der Sprache C auf eine recht einfache und intuitive Weise zum Leben. Wir beginnen mit den Schl\u00fcsselw\u00f6rtern &#8216;typdef struct&#8217;, dann setzen wir in geschweifte Klammern die so genannte Liste der Struktur-Variablen, die einfach eine Liste von Elementen ist, die den Objekten auf der Grundlage dieser Struktur zugewiesen werden. In unserem Beispiel werden wir die gew\u00fcnschte Person beschreiben, also verwenden wir ein Array vom Typ char, um den Namen zu speichern, eine uint8_t-Variable, um das Alter zu speichern und eine Flie\u00dfkommazahl, um die Gr\u00f6\u00dfe der beschriebenen Person darzustellen. Wir schlie\u00dfen die Definition der Struktur ab, indem wir ihr einen Namen geben. In diesem Fall hei\u00dft sie einfach Person.<\/p>\n<p style=\"font-weight: 400\">Eine auf diese Weise vorbereitete Struktur erm\u00f6glicht es uns, eine Art &#8216;Objekt&#8217; im Code zu erstellen, aber dazu kommen wir gleich. An dieser Stelle muss ich erw\u00e4hnen, dass diese Art der Beschreibung nicht wirklich der C-Sprachtheorie entspricht. In dem &#8220;reinen&#8221; Beispiel kommt das Schl\u00fcsselwort typedef nicht vor und der Name der Struktur steht unmittelbar nach dem Wort struct. Diese etwas komplizierte Definition der Struktur, die ich bereitgestellt habe, folgt jedoch den ungeschriebenen Regeln der Sprache C. Mit ihr m\u00fcssen wir das Wort struct nicht jedes Mal verwenden, wenn wir uns auf Objekte beziehen, denn dank typedef wird es zu einer Art &#8220;festen Typdefinition&#8221;.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-74d34ca elementor-widget elementor-widget-code-highlight\" data-id=\"74d34ca\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"prismjs-okaidia copy-to-clipboard word-wrap\">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-c line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-c\">\n\t\t\t\t\t<xmp>#include \"pico\/stdlib.h\"\r\n#include \r\n\r\n\/\/ structure declaration\r\ntypedef struct {\r\n    char name[20];\r\n    u_int8_t age;\r\n    float height;\r\n} Person;\r\n\r\nint main() {\r\n    stdio_init_all(); \/\/initialization of the stdio library\r\n\r\n    \/\/ Create an instance of the Person structure\r\n    Person Rafal;\r\n    Person Kuba;\r\n\r\n    \/\/ Assigning values to structure fields\r\n    snprintf(Rafal.name, sizeof(Rafal.name), \"Rafal\");\r\n    Rafal.age = 24;\r\n    Rafal.height = 180.5;\r\n\r\n    snprintf(Kuba.name, sizeof(Kuba.name), \"Kuba\");\r\n    Kuba.age = 28;\r\n    Kuba.height = 176.0;\r\n\r\n\r\n\r\n    while (true) {\r\n    printf(\"Name: %s\\n\", Rafal.name);\r\n    printf(\"Age: %d\\n\", Rafal.age);\r\n    printf(\"Height: %.1f cm\\n\", Rafal.height);\r\n\r\n    printf(\"Name: %s\\n\", Kuba.name);\r\n    printf(\"Age: %d\\n\", Kuba.age);\r\n    printf(\"Height: %.1f cm\\n\", Kuba.height);\r\n\r\n    \/\/ delay\r\n    sleep_ms(1000);\r\n        \r\n    }\r\n}\r\n<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-9550efc elementor-widget elementor-widget-text-editor\" data-id=\"9550efc\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Das Programm, mit dem wir strukturelle Objekte zum Leben erwecken k\u00f6nnen, beginnt mit der inzwischen klassischen Implementierung von Bibliotheken. Im zweiten Schritt definieren wir, wie im obigen Beispiel beschrieben, eine Struktur, mit der es m\u00f6glich ist, eine Person mit ihrem Namen, ihrem Alter und ihrer Gr\u00f6\u00dfe zu &#8220;generieren&#8221;. Beachten Sie im Zusammenhang mit den zuvor besprochenen Arrays, dass der Vorname genau ein 20-elementiges char-Array ist, in dem wir den Vornamen unterbringen, der aus Sicht des Mikrocontrollers einfach eine Zeichenfolge ist.<\/p>\n<p style=\"font-weight: 400;\">In der Hauptfunktion main erstellen wir nach der Initialisierung der Standardbefehle der Studiobibliothek Objekte, d.h. Personen, die auf der beschriebenen Struktur basieren. Es werden Rafal und Kuba sein. Die Erstellung des strukturierten Objekts selbst ist \u00e4u\u00dferst einfach und besteht darin, den Strukturnamen &#8216;Person&#8217; und einen imagin\u00e4ren Objektnamen anzugeben. H\u00e4tten wir die theoretische Methode der C-Sprache zur Definition einer Struktur verwendet, ohne &#8220;typedef&#8221;, dann h\u00e4tten wir an dieser Stelle den zus\u00e4tzlichen Befehl struct verwenden m\u00fcssen, und so besteht keine Notwendigkeit.<\/p>\n<p style=\"font-weight: 400;\">Sobald die Objekte, d.h. Personen, ernannt wurden, k\u00f6nnen ihnen die entsprechenden Attribute zugewiesen werden. Dies ist die Aufgabe, die in den folgenden Anweisungen ausgef\u00fchrt wird. Sie gelangen zu einer einzelnen strukturierten Variablen, indem Sie den Namen des Objekts und eine einzelne Variable in der Struktur getrennt durch einen Punkt angeben. Um das Alter von Rafal hinzuzuf\u00fcgen, verwenden wir also Rafal.age und dank des Zuweisungsoperators wird 24 in die Variable &#8220;age&#8221; des Objekts &#8220;Rafal&#8221; gesetzt. Wir f\u00fcgen die Gr\u00f6\u00dfe auf \u00e4hnliche Weise hinzu, obwohl wir hier eine pr\u00e4zisere Zahl verwenden k\u00f6nnen, da diese durch eine Float-Variable beschrieben wird. Der bei weitem komplexeste Prozess ist die Namensvergabe selbst. Obwohl wir wissen, dass der Name eine Zeichenfolge ist, ist dies f\u00fcr den Mikrocontroller nicht so offensichtlich und wir k\u00f6nnen nicht einfach z.B. &#8220;Kuba.name = &#8221;Kuba&#8221;;&#8221; verwenden. Um einen Namen hinzuzuf\u00fcgen, verwenden wir den Befehl snprintf, der die entsprechende Zeichenfolge erstellt. Diese Funktion ben\u00f6tigt drei Parameter. Der erste ist der Ort, an dem der generierte Puffer abgelegt werden soll. In unserem Fall erwarten wir, dass er in einer strukturierten Variablen gespeichert wird, die dem betreffenden Objekt entspricht. Der zweite Parameter ist die Gr\u00f6\u00dfe des Speicherplatzes. Wir k\u00f6nnten sie dauerhaft als zwanzig schreiben, da dies die Gr\u00f6\u00dfe von char-Arrays ist, aber es ist besser, hier einen Befehl zu verwenden, der dies automatisch f\u00fcr uns erledigt. So funktioniert sizeof und gibt die Gr\u00f6\u00dfe des in Klammern angegebenen Elements zur\u00fcck. Das letzte Argument von snprintf ist die Zeichenfolge, die wir an die zuvor angegebene Stelle setzen. Es handelt sich dabei einfach um die Namen Rafal und Kuba, die als Zeichenfolgen geschrieben werden.<\/p>\n<p style=\"font-weight: 400;\">In einer unendlichen while-Schleife verwenden wir das inzwischen bekannte printf und senden in strukturierten Variablen gespeicherte Informationen in jedem Sekundenintervall an den Monitor der seriellen Schnittstelle.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-bffad8d elementor-widget elementor-widget-image\" data-id=\"bffad8d\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/struktura-serial-monitor.png\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"struktura serial monitor\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODI4MTcsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvc3RydWt0dXJhLXNlcmlhbC1tb25pdG9yLnBuZyJ9\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"800\" height=\"123\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struktura-serial-monitor-1024x157.png\" class=\"attachment-large size-large wp-image-82817\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struktura-serial-monitor-1024x157.png 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struktura-serial-monitor-300x46.png 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struktura-serial-monitor-768x118.png 768w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struktura-serial-monitor-1536x235.png 1536w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/struktura-serial-monitor.png 1732w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">\u00dcberwachung der seriellen Schnittstelle nach dem Programmstart. <\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-d4a057c elementor-widget elementor-widget-text-editor\" data-id=\"d4a057c\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Nach dem Hochladen des Codes auf den Raspberry Pi Pico im seriellen Monitor sollten wir die Beschreibungen der im Code erstellten Personen sehen.<\/p>\n<p style=\"font-weight: 400;\">Eine Kleinigkeit ist bei diesem Projekt erw\u00e4hnenswert. Die Struktur, die wir erstellt haben, ist nur eine, w\u00e4hrend die Objekte zwei sind und sich sozusagen auf dieselben Variablen beziehen, und es spricht nichts dagegen, noch mehr Objekte hinzuzuf\u00fcgen. Das ist die Magie von Strukturen, die in C manchmal als Pseudo-Objektkonstrukte bezeichnet werden. Das liegt daran, dass die Arbeit mit ihnen ein wenig an die Programmierung erinnert, die aus objektorientierten Sprachen wie C++ oder Python bekannt ist. Die Struktur erm\u00f6glicht es, bestimmte Daten in etwas anspruchsvollere Pakete zu gruppieren, was recht n\u00fctzlich sein kann. Stellen Sie sich vor, Sie arbeiten mit einem beliebigen Sensor (dazu mehr im n\u00e4chsten Artikel), dessen Handhabung auf Variablen oder Konstanten basieren k\u00f6nnte. Das Programm w\u00fcrde gut funktionieren, aber es k\u00f6nnte schwierig sein, jegliche Arten von \u00c4nderungen vorzunehmen. Es ist viel besser, einen solchen Sensor zu einem Objekt mit eigenen Attributen zu machen. Dann sieht der Code viel besser aus, und auch die Kommunikation selbst wird \u00fcberdurchschnittlich gut realisiert. F\u00fcr den Moment reicht jedoch das Grundwissen \u00fcber die Erstellung und Verwendung der Strukturen aus; wir werden uns in Zukunft mit komplexeren Beispielen besch\u00e4ftigen.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-df0f4fc elementor-widget elementor-widget-heading\" data-id=\"df0f4fc\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">\u00dcbermittlung von Daten an eine Funktion \u00fcber einen Indikator <\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-bf800e7 elementor-widget elementor-widget-text-editor\" data-id=\"bf800e7\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Ein Thema, das wir bereits angesprochen haben, sind Indikatoren. Bisher haben wir einfache Beispiele entwickelt, in denen wir die Adressen der im Speicher des Mikrocontrollers gespeicherten Variablen lesen. Nun ist es jedoch an der Zeit, sich ein Programm anzusehen, das die Essenz dieser Elemente der Sprache C tats\u00e4chlich nutzt, n\u00e4mlich die \u00dcbermittlung von Daten an eine Funktion \u00fcber einen Indikator. Auch wenn es sich etwas kompliziert anh\u00f6rt, ist das Verfahren \u00fcberhaupt nicht \u00fcberm\u00e4\u00dfig kompliziert und bietet einen gro\u00dfen Vorteil.<\/p>\n<p style=\"font-weight: 400;\">F\u00fcr dieses Beispiel habe ich ein weiteres Projekt mit dem Namen increase_variable erstellt, in dem wir eine Funktion schreiben werden, die die Variable bei jedem Aufruf um eins erh\u00f6ht. Dies ist eine einfache Aufgabe, da die Erh\u00f6hung des Wertes um eins bereits aus dem vorherigen Material bekannt ist, aber dieses Mal werden wir es auf eine etwas anspruchsvollere Weise realisieren. Lassen Sie uns also direkt zum Code kommen.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-e755bf5 elementor-widget elementor-widget-code-highlight\" data-id=\"e755bf5\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"prismjs-okaidia copy-to-clipboard \">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-c line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-c\">\n\t\t\t\t\t<xmp>#include \r\n#include \"pico\/stdlib.h\"\r\n\r\nuint8_t number = 0;\r\n\r\n\/\/ A function that increases the value of the indicated variable by 1\r\nvoid increase_variable(uint8_t *num) {\r\n    (*num)++;\r\n}\r\n\r\nint main() {\r\n    stdio_init_all();\r\n\r\n    while (true) {\r\n        \r\n        printf(\"Before incrementation: %d\\n\", number);\r\n        increase_variable(&amp;number);\r\n        printf(\"After inctementation: %d\\n\", number);\r\n        sleep_ms(500);\r\n    }\r\n\r\n}\r\n<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-170f18c elementor-widget elementor-widget-text-editor\" data-id=\"170f18c\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Das Programm beginnt wie \u00fcblich mit der Einbindung von Bibliotheken und der Erstellung der Variablen &#8220;number&#8221;, deren Anfangswert Null ist und die wir sp\u00e4ter im Code \u00e4ndern wollen. Ich habe au\u00dferdem eine Funktion increase_variable vom Typ void erstellt. Auch sie wird uns keinen Wert zur\u00fcckgeben, aber in den Argumenten erwartet sie einen Indikator auf Daten vom Typ uint8_t, die wir im Folgenden als &#8220;num&#8221; bezeichnen werden. Die Funktion f\u00fchrt tats\u00e4chlich nur eine Anweisung aus, um den Wert unter dem im Argument angegebenen Zeiger zu erh\u00f6hen. Wir k\u00f6nnen also davon ausgehen, dass beim Aufruf der Funktion die Daten, auf die wir einen Zeiger \u00fcbergeben, um eins erh\u00f6ht werden.<\/p>\n<p style=\"font-weight: 400;\">Der Hauptteil des Programms wurde in eine while-Schleife eingef\u00fcgt. Wir zeigen den aktuellen Zustand der Variablen number an, rufen dann die Funktion increase_variable auf und geben dank des Adressenextraktionsoperators im Argument den Speicherplatz an, an dem number gespeichert wurde. Sobald dieser Vorgang abgeschlossen ist, sendet das Programm erneut den in unserer Variablen gespeicherten Wert an den seriellen Monitor.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-f37dd00 elementor-widget elementor-widget-image\" data-id=\"f37dd00\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/wskaznik-funkcja-monitor.png\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"wskaznik funkcja monitor\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODI4MjEsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvd3NrYXpuaWstZnVua2NqYS1tb25pdG9yLnBuZyJ9\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"800\" height=\"118\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/wskaznik-funkcja-monitor-1024x151.png\" class=\"attachment-large size-large wp-image-82821\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/wskaznik-funkcja-monitor-1024x151.png 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/wskaznik-funkcja-monitor-300x44.png 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/wskaznik-funkcja-monitor-768x113.png 768w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/wskaznik-funkcja-monitor-1536x227.png 1536w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/wskaznik-funkcja-monitor.png 1706w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Zahlenwerte, die im Monitor der seriellen Schnittstelle sichtbar sind.<\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-2b7b90b elementor-widget elementor-widget-text-editor\" data-id=\"2b7b90b\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Nach der Ausf\u00fchrung des Programms sollte der Computerbildschirm aufeinanderfolgende Werte der variablen Zahl anzeigen, die sich jede halbe Sekunde um eins erh\u00f6hen. Mit diesem einfachen Programm haben wir die \u00dcbergabe von Daten an eine Funktion \u00fcber einen Zeiger implementiert. Das mag wie nichts Besonderes aussehen, aber der gr\u00f6\u00dfte Vorteil dieser L\u00f6sung ist etwas, das wir nicht sehen k\u00f6nnen.<\/p>\n<p style=\"font-weight: 400;\">Lassen Sie uns \u00fcberlegen, was passieren w\u00fcrde, wenn wir uns entschlie\u00dfen w\u00fcrden, eine gew\u00f6hnliche Variable in das Argument einer Funktion zu setzen. Wenn in diesem Fall eine Variable an increase_variable \u00fcbergeben wird, wird eine Kopie der Variable erzeugt, an der die Inkrementierungsoperation durchgef\u00fchrt wird. Und nur aus der Kopie k\u00f6nnen wir den um eins erh\u00f6hten Wert entnehmen. Ich denke, Sie wissen bereits, worum es hier geht. In diesem Fall erstellen wir v\u00f6llig unn\u00f6tigerweise eine zus\u00e4tzliche Variable f\u00fcr uns, die wir nicht sehen k\u00f6nnen, die aber Platz im Speicher beansprucht. Mit dem Zeiger k\u00f6nnen wir dies vermeiden, denn wir geben nur die Adresse an, so dass die gesamte Operation mit dem urspr\u00fcnglichen Wert durchgef\u00fchrt wird. Diese L\u00f6sung hat eine Reihe von Vorteilen. Zun\u00e4chst einmal k\u00f6nnen wir die Werte der Variablen direkt manipulieren, was auch die Effizienz des Codes erh\u00f6ht. Au\u00dferdem ist eine solche L\u00f6sung in Zukunft sicherer, denn wenn wir unsere eigenen Bibliotheken schreiben, die von anderen Benutzern verwendet werden sollen, sind wir immun gegen die Eingabe falscher Daten durch diese Benutzer. Unser Code erwartet nur eine Adresse, wir f\u00fchren unsere eigenen Operationen durch und k\u00fcmmern uns nicht darum, wie sich dies auf den Code Dritter auswirkt, wir waschen sozusagen unsere H\u00e4nde in Unschuld. Ob der Benutzer den richtigen Indikator angibt, h\u00e4ngt allein von ihm ab. Allerdings muss ich auch erw\u00e4hnen, dass in der Sprache C so etwas wie ein Typkonflikt, der entstehen kann, wenn Daten \u00fcber einen Zeiger \u00fcbergeben werden, durch das so genannte Casting gel\u00f6st wird, aber mit diesem Thema werden wir uns ein anderes Mal besch\u00e4ftigen.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-44c156b elementor-widget elementor-widget-heading\" data-id=\"44c156b\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">Entwurf eines Zustandsautomaten <\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-6a2d9ca elementor-widget elementor-widget-text-editor\" data-id=\"6a2d9ca\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Bisher haben wir unsere Programme vor allem entwickelt, um bestimmte Funktionen zu testen, RPI-Leitungen zu steuern, ADCs zu bedienen oder \u00fcber USB zu kommunizieren. Wir haben diese Codes im Hinblick auf ihre Funktion, aber nicht unbedingt auf ihre Leistung als Ganzes analysiert, also ist es an der Zeit, dies zu \u00e4ndern. In diesem Unterabschnitt werden wir ein etwas gr\u00f6\u00dferes Projekt vorbereiten, das auf dem bekannten Konzept des Zustandsautomaten in C basiert. Da drei LEDs an den Raspberry Pi Pico angeschlossen sind, k\u00f6nnen wir ein Programm vorbereiten, das eine Ampel simuliert. Neben dem klassischen Wechsel von Rot auf Gr\u00fcn und umgekehrt werden wir jedoch auch einen speziellen Servicemodus einf\u00fchren, bei dem nur die gelbe LED blinkt. F\u00fcr diese \u00dcbung habe ich ein weiteres Projekt mit dem Namen state_machine vorbereitet, aber bevor wir uns mit dem Code befassen, sollten wir uns das Konzept eines Zustandsautomaten genauer ansehen.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-765d8a0 elementor-widget elementor-widget-image\" data-id=\"765d8a0\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/stsate-swiatla-diagram.png\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"stsate swiatla diagram\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODI4MjUsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvc3RzYXRlLXN3aWF0bGEtZGlhZ3JhbS5wbmcifQ%3D%3D\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"800\" height=\"280\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/stsate-swiatla-diagram-1024x359.png\" class=\"attachment-large size-large wp-image-82825\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/stsate-swiatla-diagram-1024x359.png 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/stsate-swiatla-diagram-300x105.png 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/stsate-swiatla-diagram-768x269.png 768w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/stsate-swiatla-diagram.png 1101w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Grafische Darstellung der aufeinanderfolgenden Ampelzust\u00e4nde.<\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-65301b2 elementor-widget elementor-widget-text-editor\" data-id=\"65301b2\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Gem\u00e4\u00df der definition k\u00f6nnen wir einen Zustandsautomaten als ein mathematisches Berechnungsmodell definieren, das ein System durch eine endliche Anzahl von Zust\u00e4nden, \u00dcberg\u00e4ngen zwischen ihnen und den durch diese \u00dcberg\u00e4nge ausgel\u00f6sten Aktionen darstellt. Das klingt etwas kompliziert und es ist viel besser zu sagen, dass ein Zustandsautomat einfach ein Modell ist, in der Regel ein grafisches, das Schritt f\u00fcr Schritt den Betrieb eines bestimmten Programms oder Ger\u00e4ts beschreibt. Mit einem solchen Modell l\u00e4sst sich auch der Betrieb einer Stra\u00dfenverkehrsampel beschreiben. Zun\u00e4chst ist das rote Licht aktiv, dann wechselt es zu Gelb, so dass nach einer Weile das gr\u00fcne Signal aktiviert wird, w\u00e4hrend der letzte Zustand vor der R\u00fcckkehr zu Rot das gelbe Licht ist (dies ist ein dreiphasiges Ampelsystem, das unter anderem aus den USA und Frankreich bekannt ist; in Polen wird ein vierphasiges Modell verwendet). Mit einer solchen Beschreibung ist es viel einfacher, ein Programm zu erstellen, das dieser Aufgabe gerecht wird. Nat\u00fcrlich k\u00f6nnten wir einen einfachen Code schreiben, der die entsprechenden LEDs, die der oben erw\u00e4hnten Signalleuchte entsprechen, eine nach der anderen aktiviert, aber in diesem Projekt werden wir die viel interessantere Funktion switch&#8230;case verwenden. Au\u00dferdem werden wir der Einfachheit halber versuchen, einen speziellen Modus vorzubereiten, bei dem es dem potenziellen Verkehrsteilnehmer \u00fcberlassen bleibt, den vertikalen Schildern zu folgen. In diesem Fall blinkt die Ampel gelb.<\/p>\n<p style=\"font-weight: 400;\">Bevor wir uns jedoch dem Code zuwenden, m\u00fcssen Sie eine weitere Neuheit der Sprache C kennenlernen, den so genannten Aufz\u00e4hlungstyp, der es uns erm\u00f6glicht, die Zust\u00e4nde zu beschreiben, in denen sich eine Signalleuchte befinden kann.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-4663f65 elementor-widget elementor-widget-image\" data-id=\"4663f65\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/enum-1024x576-1.jpg\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"enum-1024x576\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODM2NTMsInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvZW51bS0xMDI0eDU3Ni0xLmpwZyJ9\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"800\" height=\"450\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/enum-1024x576-1.jpg\" class=\"attachment-large size-large wp-image-83653\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/enum-1024x576-1.jpg 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/enum-1024x576-1-300x169.jpg 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/enum-1024x576-1-768x432.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Deklaration eines Aufz\u00e4hlungstyps. <\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-d0894b4 elementor-widget elementor-widget-text-editor\" data-id=\"d0894b4\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Genauso wie wir Variablen in Programmen platzieren, m\u00fcssen wir auch die Zust\u00e4nde, in denen sich eine Ampel befinden kann, irgendwie benennen und definieren. Am einfachsten ist es, sich auf die Farbe zu beziehen, die gerade aktiv ist. Wenn eine gr\u00fcne LED leuchtet, bezeichnen wir diesen Zustand als gr\u00fcn, das Gleiche gilt f\u00fcr rotes Licht. Es ist erw\u00e4hnenswert, dass das gelbe Licht in zwei F\u00e4llen leuchtet, n\u00e4mlich beim \u00dcbergang von Gr\u00fcn zu Rot oder umgekehrt, so dass wir auch solche Zust\u00e4nde beschreiben m\u00fcssen. Dar\u00fcber hinaus m\u00fcssen wir auch an den speziellen Servicemodus denken.<\/p>\n<p style=\"font-weight: 400;\">Wir k\u00f6nnten die verschiedenen Zust\u00e4nde in verschiedenen Variablen speichern, aber es gibt einen viel besseren Weg, den Aufz\u00e4hlungstyp. Bis jetzt waren die Variablen, die wir verwendet haben, bestimmten Datentypen gewidmet, z.B. float speichert immer Flie\u00dfkommazahlen. Enum, auch bekannt als Aufz\u00e4hlungstyp, erm\u00f6glicht es uns, eine eigene Variable zu erstellen, die unsere eigenen Werte speichert.<\/p>\n<p style=\"font-weight: 400;\">Wir deklarieren den Aufz\u00e4hlungstyp auf \u00e4hnliche Weise wie Strukturen. Wir beginnen mit den Schl\u00fcsselw\u00f6rtern &#8220;typedef enum&#8221; und setzen in geschweiften Klammern unsere eigenen Wertetypen ein, die die durch die enum beschriebene Variable akzeptieren kann. Ganz am Ende f\u00fcgen wir auch einen Namen hinzu, den wir im Rest des Codes verwenden werden.<\/p>\n<p style=\"font-weight: 400;\">Auf diese Weise haben wir sozusagen unseren eigenen Variablentyp namens traffic_light_state_t geschaffen, der den aktuellen Zustand unseres Zustandsautomaten speichert, mit anderen Worten, den Zustand, in dem sich die Ampel befindet. Dies ist z.B. STATE_GREEN, was einer gr\u00fcnen Signalleuchte entspricht.<\/p>\n<p style=\"font-weight: 400;\">In diesem Fall, wie auch bei der Struktur, habe ich mich entschieden, Ihnen sofort eine etwas aufwendigere Enum-Deklaration zu pr\u00e4sentieren, mit dem Wort typedef am Anfang. Die Motivation war hier identisch mit der vorhergehenden, und daher wird das enum-Pr\u00e4fix im restlichen Code nicht ben\u00f6tigt.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-c61a997 elementor-widget elementor-widget-code-highlight\" data-id=\"c61a997\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"prismjs-okaidia copy-to-clipboard word-wrap\">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-c line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-c\">\n\t\t\t\t\t<xmp>#include \"pico\/stdlib.h\"\r\n\r\n#define GREEN_LED 0\r\n#define YELLOW_LED 1\r\n#define RED_LED 2\r\n#define BUTTON_PIN 16\r\n\r\n\/\/ States of the state machine for traffic lights\r\ntypedef enum {\r\n    STATE_GREEN,\r\n    STATE_YELLOW_TO_RED,\r\n    STATE_RED,\r\n    STATE_YELLOW_TO_GREEN,\r\n    STATE_SERVICE\r\n} traffic_light_state_t;\r\n\r\n\/\/ Function to set the status of the LED\r\nvoid set_traffic_light(traffic_light_state_t state) {\r\n    gpio_put(GREEN_LED, state == STATE_GREEN);\r\n    gpio_put(YELLOW_LED, state == STATE_YELLOW_TO_RED || state == STATE_YELLOW_TO_GREEN);\r\n    gpio_put(RED_LED, state == STATE_RED);\r\n}\r\n\r\nint main() {\r\n    stdio_init_all();\r\n\r\n    gpio_init(GREEN_LED);\r\n    gpio_set_dir(GREEN_LED, GPIO_OUT);\r\n\r\n    gpio_init(YELLOW_LED);\r\n    gpio_set_dir(YELLOW_LED, GPIO_OUT);\r\n\r\n    gpio_init(RED_LED);\r\n    gpio_set_dir(RED_LED, GPIO_OUT);\r\n\r\n    gpio_init(BUTTON_PIN);\r\n    gpio_set_dir(BUTTON_PIN, GPIO_IN);\r\n    gpio_pull_up(BUTTON_PIN);  \/\/ W\u0142\u0105czenie wewn\u0119trznego rezystora podci\u0105gaj\u0105cego\r\n\r\n    \/\/ Initial signaling status\r\n    traffic_light_state_t state = STATE_GREEN;\r\n    bool service_mode = false;\r\n\r\n    while (true) {\r\n        \/\/ Checking the status of the button\r\n            if (gpio_get(BUTTON_PIN) == 0) {\r\n                service_mode = !service_mode;\r\n                while (gpio_get(BUTTON_PIN) == 0);  \/\/ Waiting for the button to be released\r\n\r\n                if (service_mode) {\r\n                    state = STATE_SERVICE;\r\n                } else {\r\n                    state = STATE_GREEN; \/\/ Return to normal state after service mode\r\n                }\r\n        }\r\n\r\n        \r\n        switch (state) {\r\n            case STATE_GREEN:\r\n                set_traffic_light(STATE_GREEN);\r\n                sleep_ms(5000); \/\/ Zielone \u015bwiat\u0142o \u015bwieci przez 5 sekund\r\n                if (!service_mode) state = STATE_YELLOW_TO_RED;\r\n                break;\r\n\r\n            case STATE_YELLOW_TO_RED:\r\n                set_traffic_light(STATE_YELLOW_TO_RED);\r\n                sleep_ms(2000); \/\/ Yellow light illuminates for 2 seconds\r\n                if (!service_mode) state = STATE_RED;\r\n                break;\r\n\r\n            case STATE_RED:\r\n                set_traffic_light(STATE_RED);\r\n                sleep_ms(5000); \/\/ Red light illuminates for 5 seconds\r\n                if (!service_mode) state = STATE_YELLOW_TO_GREEN;\r\n                break;\r\n\r\n            case STATE_YELLOW_TO_GREEN:\r\n                set_traffic_light(STATE_YELLOW_TO_GREEN);\r\n                sleep_ms(2000); \/\/ Yellow light illuminates for 2 seconds\r\n                if (!service_mode) state = STATE_GREEN;\r\n                break;\r\n\r\n            case STATE_SERVICE:\r\n                gpio_put(GREEN_LED, 0);\r\n                gpio_put(RED_LED, 0);\r\n                \/\/ Blinking yellow light\r\n                gpio_put(YELLOW_LED, 1);\r\n                sleep_ms(500);\r\n                gpio_put(YELLOW_LED, 0);\r\n                sleep_ms(500);\r\n                break;\r\n        }\r\n    }\r\n\r\n}\r\n<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-3491998 elementor-widget elementor-widget-text-editor\" data-id=\"3491998\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400;\">Wie \u00fcblich beginnen wir das Programm, indem wir die Bibliothek einbinden und die Pins definieren, an denen die LEDs und die Taste angeschlossen sind. Im n\u00e4chsten Schritt wird eine Aufz\u00e4hlungstyp-Deklaration platziert, die ich oben beschrieben habe, sowie eine Funktion, die den entsprechenden LED-Status setzt, aber dazu kommen wir gleich.<\/p>\n<p style=\"font-weight: 400;\">Zu Beginn der Hauptfunktion haben wir die von uns verwendeten Raspberry Pi Pico-Kabel initialisiert und den Anfangszustand unserer Signalisierung festgelegt. Hier erstellen wir zwei Variablen state und service_mode. Der erste ist ein Wert unseres speziellen Typs, so dass wir ihm nur ausgew\u00e4hlte Zust\u00e4nde zuweisen k\u00f6nnen. Der Standardwert ist STATE_GREEN, also das aktive gr\u00fcne Licht. Wir werden eine Variable vom Typ bool mit der Bezeichnung service_mode verwenden, um den Service-Modus f\u00fcr die Signalisierung zu aktivieren. Ihr Standardwert ist false, da es keinen Grund gibt, diesen Zustand gleich zu Beginn des Programms zu aktivieren.<\/p>\n<p style=\"font-weight: 400;\">Wir werden den Betrieb der Ampel in einer while-Schleife beschreiben. Darin muss es einen Tastendienst geben, der den Service-Modus aktiviert, d.h. den Wert des Zustands auf STATE_SERVICE \u00e4ndert, und eine Abh\u00e4ngigkeit, um die nachfolgenden Zust\u00e4nde der Ampel zu \u00e4ndern und entsprechend zu reagieren. Nehmen wir zun\u00e4chst den Tastendienst, der mit einem kurzen St\u00fcck Code am Anfang einer unendlichen while-Schleife implementiert wird. Ganz am Anfang m\u00fcssen wir den Zustand des Knopfes mit der Funktion gpio_get \u00fcberpr\u00fcfen; wenn der gelesene Wert Null ist, d.h. der Knopf ist gedr\u00fcckt und der RPI-Pin ist mit Masse kurzgeschlossen, k\u00f6nnen wir den Wert der Variablen service_mode in das Gegenteil \u00e4ndern. Hier verwenden wir den Operator &#8220;!&#8221;, der der Variablen den entgegengesetzten Zustand zuweist. Im n\u00e4chsten Schritt m\u00fcssen wir darauf warten, dass der Knopf losgelassen wird. Hier verwenden wir eine clevere Konstruktion, die auf der while-Schleife basiert. Wir \u00fcberpr\u00fcfen den Zustand der Taste ein zweites Mal, und wenn die Taste immer noch gedr\u00fcckt ist, fallen wir in die Schleife. Innerhalb der Schleife weisen wir mit einer bedingten Funktion, die von der Variable service_mode abh\u00e4ngt, state den entsprechenden Zustand zu. Wenn die Variable eine logische Variable ist, aktivieren wir STATE_SERVICE, andernfalls aktivieren wir den Standardzustand des gr\u00fcnen Lichts. Diese Schleife ist so lange aktiv, bis die Taste losgelassen wird; danach befinden wir uns immer im Service- oder Standardmodus.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-bdfe0c2 elementor-widget elementor-widget-image\" data-id=\"bdfe0c2\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t<figure class=\"wp-caption\">\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/case-1024x576-1.jpg\" data-elementor-open-lightbox=\"yes\" data-elementor-lightbox-title=\"case-1024x576\" data-e-action-hash=\"#elementor-action%3Aaction%3Dlightbox%26settings%3DeyJpZCI6ODM2NTksInVybCI6Imh0dHBzOlwvXC9ib3RsYW5kLmRlXC9ibG9nXC93cC1jb250ZW50XC91cGxvYWRzXC8yMDI0XC8wNlwvY2FzZS0xMDI0eDU3Ni0xLmpwZyJ9\" data-wpel-link=\"internal\">\n\t\t\t\t\t\t\t<img loading=\"lazy\" decoding=\"async\" width=\"800\" height=\"450\" src=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/case-1024x576-1.jpg\" class=\"attachment-large size-large wp-image-83659\" alt=\"\" srcset=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/case-1024x576-1.jpg 1024w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/case-1024x576-1-300x169.jpg 300w, https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/case-1024x576-1-768x432.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/>\t\t\t\t\t\t\t\t<\/a>\n\t\t\t\t\t\t\t\t\t\t\t<figcaption class=\"widget-image-caption wp-caption-text\">Das Prinzip der Verwendung der Funktion switch...case.<\/figcaption>\n\t\t\t\t\t\t\t\t\t\t<\/figure>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-68e95f7 elementor-widget elementor-widget-text-editor\" data-id=\"68e95f7\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Die Funktion, die tats\u00e4chlich die Funktionsweise unserer Signalisierung definiert, ist die bereits erw\u00e4hnte switch&#8230;case. Dies ist eine interessante Konstruktion, die wir in gewisser Weise als bedingt bezeichnen k\u00f6nnten, abh\u00e4ngig von einer einzigen Variable. Nach dem Schl\u00fcsselwort &#8220;switch&#8221; platzieren wir eine Variable, von der der als n\u00e4chstes auszuf\u00fchrende Code abh\u00e4ngt. In unserem Fall wird dies &#8216;state&#8217; sein, denn hier wird der aktuelle Status der Ampel gespeichert. Im Folgenden wird auf jeden m\u00f6glichen Wert von &#8220;state&#8221; reagiert. Standardm\u00e4\u00dfig wird der unten beschriebene Codeschnipsel case STATE_GREEN beim Start des Programms ausgef\u00fchrt. In diesem Zustand rufen wir die Funktion set_traffic_light auf und setzen STATE_GREEN in ihr Argument. Wenn wir zum Anfang des Programms zur\u00fcckgehen, wo die Funktion beschrieben wird, stellen wir fest, dass die Aktivierung der LED genau von dem im Argument \u00fcbergebenen Wert abh\u00e4ngt. Wenn STATE_GREEN vorhanden ist, ist die gr\u00fcne LED aktiviert. Nach dem Aufruf der Funktion, die den entsprechenden Status am RPI-Pin einstellt, wartet das Programm f\u00fcnf Sekunden lang und pr\u00fcft dann, ob der Servicemodus aktiviert wurde. Falls nicht, wird dem Statuswert der Wert STATE_YELLOW_TO_RED zugewiesen, da dies der Status ist, in dem sich die Signalisierung jetzt befinden sollte. Beachten Sie, dass ich hier eine interessante Konstruktion verwendet habe, bei der der if-Operator von geschweiften Klammern befreit wurde. Wenn es sich bei dem in der Bedingung ausgef\u00fchrten Code nur um eine einzige Funktion handelt, k\u00f6nnen wir sie in derselben Zeile wie die if-Anweisung unterbringen, was unser Programm etwas verk\u00fcrzt und seine Lesbarkeit verbessert. Wenn dieser Code ausgef\u00fchrt wird, wird die Funktion switch&#8230;case durch das Schl\u00fcsselwort &#8216;break&#8217; unterbrochen und das Programm kehrt an den Anfang der while-Schleife zur\u00fcck.<\/p>\n<p style=\"font-weight: 400\">Hier wird der Zustand der Taste erneut \u00fcberpr\u00fcft und wenn die Taste nicht gedr\u00fcckt wurde, geht das Programm zu switch&#8230;case \u00fcber, aber dieses Mal f\u00fchrt der Mikrocontroller den Code unter dem case-Wert STATE_YELLOW_TO_RED aus, je nach dem Zustand der State-Variablen, der sich w\u00e4hrend des vorherigen Schleifendurchlaufs ge\u00e4ndert hat. Die Anweisungen hier sehen analog zu den vorherigen aus und wenn die aktive LED wechselt, wird &#8216;state&#8217; ein anderer Zustand zugewiesen, so dass der mit STATE_RED verbundene Code beim n\u00e4chsten Schleifendurchlauf ausgef\u00fchrt werden kann. So funktioniert die Funktion switch&#8230;case, mit der Sie auf verschiedene Zust\u00e4nde derselben Variablen reagieren k\u00f6nnen.<\/p>\n<p style=\"font-weight: 400\">Die letzte switch&#8230;case-Bedingung beschreibt die Antwort auf STATE_SERVICE. Wenn die Taste gedr\u00fcckt wird, ist dies der Wert, der der Statusvariablen zugewiesen wird und die gelbe LED blinkt dann.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-e13a35e elementor-widget elementor-widget-video\" data-id=\"e13a35e\" data-element_type=\"widget\" data-e-type=\"widget\" data-settings=\"{&quot;video_type&quot;:&quot;hosted&quot;,&quot;controls&quot;:&quot;yes&quot;}\" data-widget_type=\"video.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"e-hosted-video elementor-wrapper elementor-open-inline\">\n\t\t\t\t\t<video class=\"elementor-video\" src=\"https:\/\/botland.com.pl\/blog\/wp-content\/uploads\/2024\/06\/swiatla2.mov\" controls=\"\" preload=\"metadata\" controlsList=\"nodownload\"><\/video>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-52889fe elementor-widget elementor-widget-text-editor\" data-id=\"52889fe\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Nachdem wir den Code ausgef\u00fchrt haben, k\u00f6nnen wir unsere Miniatur-Ampel in Betrieb sehen. Der erste Zustand ist ein gr\u00fcnes Licht, das nacheinander in gelb und rot \u00fcbergeht, wie es auch im wirklichen Leben der Fall ist. Wenn Sie die Taste einen Moment lang gedr\u00fcckt halten, wird der Service-Modus aktiviert, in dem die Leuchte gelb blinkt. Wenn Sie die Taste erneut dr\u00fccken, kehren Sie in den Standardmodus zur\u00fcck.<\/p>\n<p style=\"font-weight: 400\">Ich wei\u00df, dass das Projekt des Zustandsautomaten etwas kompliziert erscheinen kann. Wenn Sie sich also nicht 100-prozentig sicher sind, sollten Sie es noch einmal durchgehen und selbst experimentieren, indem Sie bestimmte Werte und Zust\u00e4nde \u00e4ndern und dann sehen, wie das Programm reagiert. Denken Sie daran, dass alles von der Statusvariable abh\u00e4ngt. Sie definiert den aktuellen Status der Signalleuchte und den n\u00e4chsten Status. Und auf dieser Grundlage funktioniert die Funktion switch&#8230;case, die durch den Aufruf des Befehls set_traffic_light die LEDs entsprechend ausschaltet.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-3164b73 elementor-widget elementor-widget-heading\" data-id=\"3164b73\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">Ein paar Worte zum Schluss...<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-2e42788 elementor-widget elementor-widget-text-editor\" data-id=\"2e42788\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Einer der definitiv gr\u00f6\u00dferen Artikel in dieser Serie liegt hinter uns. Wir haben heute eine Menge \u00fcber neue Dinge gelernt &#8211; Arrays, Strukturen, Zeiger\u00fcbergabe und wir haben auch ein Ampelprojekt auf der Grundlage eines Zustandsautomaten gestartet. Nach zehn Teilen verf\u00fcgen wir bereits \u00fcber ein solides Fundament der Sprache C, das wir mit realen Beispielen getestet haben. Im n\u00e4chsten Artikel werden wir also echte Experimente starten und einen digitalen Lichtsensor an unseren Raspberry anschlie\u00dfen.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-ed65f6f elementor-widget elementor-widget-spacer\" data-id=\"ed65f6f\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"spacer.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<div class=\"elementor-spacer\">\n\t\t\t<div class=\"elementor-spacer-inner\"><\/div>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-e12255d elementor-widget elementor-widget-text-editor\" data-id=\"e12255d\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p style=\"font-weight: 400\">Quellen:<\/p>\n<ul>\n<li style=\"font-weight: 400\">https:\/\/datasheets.raspberrypi.com\/rp2040\/rp2040-datasheet.pdf<\/li>\n<li style=\"font-weight: 400\">https:\/\/datasheets.raspberrypi.com\/picow\/pico-w-datasheet.pdf<\/li>\n<li style=\"font-weight: 400\">https:\/\/www.raspberrypi.com\/products\/rp2040\/<\/li>\n<li style=\"font-weight: 400\">https:\/\/www.raspberrypi.com\/documentation\/microcontrollers\/raspberry-pi-pico.html<\/li>\n<\/ul>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"<p>In diesem Teil des Kurses werden wir uns ein Konstrukt namens Struktur ansehen und ich werde Ihnen auch erkl\u00e4ren, wie man Zustandsautomaten in C erstellt.<\/p>\n","protected":false},"author":34,"featured_media":83424,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[7,21,134],"tags":[],"class_list":["post-83432","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-elektronika","category-programowanie","category-raspberry-pi"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.4 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Raspberry Pi Pico Kurs - #10 - Arrays, Strukturen und Zustandsautomaten - Botland<\/title>\n<meta name=\"description\" content=\"In diesem Teil des Kurses werden wir uns ein Konstrukt namens Struktur ansehen und ich werde Ihnen auch erkl\u00e4ren, wie man Zustandsautomaten in C erstellt.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Raspberry Pi Pico Kurs - #10 - Arrays, Strukturen und Zustandsautomaten - Botland\" \/>\n<meta property=\"og:description\" content=\"In diesem Teil des Kurses werden wir uns ein Konstrukt namens Struktur ansehen und ich werde Ihnen auch erkl\u00e4ren, wie man Zustandsautomaten in C erstellt.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/\" \/>\n<meta property=\"og:site_name\" content=\"Botland\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/facebook.com\/Botland\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-06-24T12:00:57+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-04-08T08:55:36+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/1.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1510\" \/>\n\t<meta property=\"og:image:height\" content=\"755\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Rafa\u0142 Bartoszak\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Rafa\u0142 Bartoszak\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"31\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/\"},\"author\":{\"name\":\"Rafa\u0142 Bartoszak\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/#\\\/schema\\\/person\\\/5a69e7f5db1f77c617f990e73bb83215\"},\"headline\":\"Raspberry Pi Pico Kurs &#8211; #10 &#8211; Arrays, Strukturen und Zustandsautomaten\",\"datePublished\":\"2024-06-24T12:00:57+00:00\",\"dateModified\":\"2026-04-08T08:55:36+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/\"},\"wordCount\":5469,\"publisher\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/botland.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/06\\\/1.png\",\"articleSection\":[\"Elektronika\",\"Programowanie\",\"Raspberry Pi\"],\"inLanguage\":\"de\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/\",\"url\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/\",\"name\":\"Raspberry Pi Pico Kurs - #10 - Arrays, Strukturen und Zustandsautomaten - Botland\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/botland.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/06\\\/1.png\",\"datePublished\":\"2024-06-24T12:00:57+00:00\",\"dateModified\":\"2026-04-08T08:55:36+00:00\",\"description\":\"In diesem Teil des Kurses werden wir uns ein Konstrukt namens Struktur ansehen und ich werde Ihnen auch erkl\u00e4ren, wie man Zustandsautomaten in C erstellt.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/#primaryimage\",\"url\":\"https:\\\/\\\/botland.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/06\\\/1.png\",\"contentUrl\":\"https:\\\/\\\/botland.de\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/06\\\/1.png\",\"width\":1510,\"height\":755},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Strona g\u0142\u00f3wna\",\"item\":\"https:\\\/\\\/botland.de\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Raspberry Pi Pico Kurs &#8211; #10 &#8211; Arrays, Strukturen und Zustandsautomaten\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/botland.de\\\/blog\\\/\",\"name\":\"Botland\",\"description\":\"Blog Raspberry Pi, Arduino, elektronika i robotyka - Botland\",\"publisher\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/botland.de\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/#organization\",\"name\":\"Botland\",\"url\":\"https:\\\/\\\/botland.de\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/botland.store\\\/blog\\\/wp-content\\\/uploads\\\/2018\\\/04\\\/logo_kolor_WP_2-1.png\",\"contentUrl\":\"https:\\\/\\\/botland.store\\\/blog\\\/wp-content\\\/uploads\\\/2018\\\/04\\\/logo_kolor_WP_2-1.png\",\"width\":250,\"height\":57,\"caption\":\"Botland\"},\"image\":{\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/facebook.com\\\/Botland\\\/\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/#\\\/schema\\\/person\\\/5a69e7f5db1f77c617f990e73bb83215\",\"name\":\"Rafa\u0142 Bartoszak\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/botland.de\\\/blog\\\/wp-content\\\/uploads\\\/2023\\\/07\\\/IMG_21531-300x300.jpg\",\"url\":\"https:\\\/\\\/botland.de\\\/blog\\\/wp-content\\\/uploads\\\/2023\\\/07\\\/IMG_21531-300x300.jpg\",\"contentUrl\":\"https:\\\/\\\/botland.de\\\/blog\\\/wp-content\\\/uploads\\\/2023\\\/07\\\/IMG_21531-300x300.jpg\",\"caption\":\"Rafa\u0142 Bartoszak\"},\"description\":\"Wsp\u00f3\u0142pracuj\u0105cy z Botlandem elektronik, kt\u00f3ry dzieli si\u0119 swoj\u0105 wiedz\u0105 w internecie. Entuzjasta system\u00f3w cyfrowych, uk\u0142ad\u00f3w programowalnych i mikroelektroniki. Pasjonat historii, ze szczeg\u00f3lnym naciskiem na wiek XX.\",\"url\":\"https:\\\/\\\/botland.de\\\/blog\\\/author\\\/rafal-bartoszak\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Raspberry Pi Pico Kurs - #10 - Arrays, Strukturen und Zustandsautomaten - Botland","description":"In diesem Teil des Kurses werden wir uns ein Konstrukt namens Struktur ansehen und ich werde Ihnen auch erkl\u00e4ren, wie man Zustandsautomaten in C erstellt.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/","og_locale":"de_DE","og_type":"article","og_title":"Raspberry Pi Pico Kurs - #10 - Arrays, Strukturen und Zustandsautomaten - Botland","og_description":"In diesem Teil des Kurses werden wir uns ein Konstrukt namens Struktur ansehen und ich werde Ihnen auch erkl\u00e4ren, wie man Zustandsautomaten in C erstellt.","og_url":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/","og_site_name":"Botland","article_publisher":"https:\/\/facebook.com\/Botland\/","article_published_time":"2024-06-24T12:00:57+00:00","article_modified_time":"2026-04-08T08:55:36+00:00","og_image":[{"width":1510,"height":755,"url":"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/1.png","type":"image\/png"}],"author":"Rafa\u0142 Bartoszak","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Rafa\u0142 Bartoszak","Gesch\u00e4tzte Lesezeit":"31\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/#article","isPartOf":{"@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/"},"author":{"name":"Rafa\u0142 Bartoszak","@id":"https:\/\/botland.de\/blog\/#\/schema\/person\/5a69e7f5db1f77c617f990e73bb83215"},"headline":"Raspberry Pi Pico Kurs &#8211; #10 &#8211; Arrays, Strukturen und Zustandsautomaten","datePublished":"2024-06-24T12:00:57+00:00","dateModified":"2026-04-08T08:55:36+00:00","mainEntityOfPage":{"@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/"},"wordCount":5469,"publisher":{"@id":"https:\/\/botland.de\/blog\/#organization"},"image":{"@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/#primaryimage"},"thumbnailUrl":"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/1.png","articleSection":["Elektronika","Programowanie","Raspberry Pi"],"inLanguage":"de"},{"@type":"WebPage","@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/","url":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/","name":"Raspberry Pi Pico Kurs - #10 - Arrays, Strukturen und Zustandsautomaten - Botland","isPartOf":{"@id":"https:\/\/botland.de\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/#primaryimage"},"image":{"@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/#primaryimage"},"thumbnailUrl":"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/1.png","datePublished":"2024-06-24T12:00:57+00:00","dateModified":"2026-04-08T08:55:36+00:00","description":"In diesem Teil des Kurses werden wir uns ein Konstrukt namens Struktur ansehen und ich werde Ihnen auch erkl\u00e4ren, wie man Zustandsautomaten in C erstellt.","breadcrumb":{"@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/#primaryimage","url":"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/1.png","contentUrl":"https:\/\/botland.de\/blog\/wp-content\/uploads\/2024\/06\/1.png","width":1510,"height":755},{"@type":"BreadcrumbList","@id":"https:\/\/botland.de\/blog\/raspberry-pi-pico-kurs-10-arrays-strukturen-und-zustandsautomaten\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Strona g\u0142\u00f3wna","item":"https:\/\/botland.de\/blog\/"},{"@type":"ListItem","position":2,"name":"Raspberry Pi Pico Kurs &#8211; #10 &#8211; Arrays, Strukturen und Zustandsautomaten"}]},{"@type":"WebSite","@id":"https:\/\/botland.de\/blog\/#website","url":"https:\/\/botland.de\/blog\/","name":"Botland","description":"Blog Raspberry Pi, Arduino, elektronika i robotyka - Botland","publisher":{"@id":"https:\/\/botland.de\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/botland.de\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/botland.de\/blog\/#organization","name":"Botland","url":"https:\/\/botland.de\/blog\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/botland.de\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/botland.store\/blog\/wp-content\/uploads\/2018\/04\/logo_kolor_WP_2-1.png","contentUrl":"https:\/\/botland.store\/blog\/wp-content\/uploads\/2018\/04\/logo_kolor_WP_2-1.png","width":250,"height":57,"caption":"Botland"},"image":{"@id":"https:\/\/botland.de\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/facebook.com\/Botland\/"]},{"@type":"Person","@id":"https:\/\/botland.de\/blog\/#\/schema\/person\/5a69e7f5db1f77c617f990e73bb83215","name":"Rafa\u0142 Bartoszak","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/botland.de\/blog\/wp-content\/uploads\/2023\/07\/IMG_21531-300x300.jpg","url":"https:\/\/botland.de\/blog\/wp-content\/uploads\/2023\/07\/IMG_21531-300x300.jpg","contentUrl":"https:\/\/botland.de\/blog\/wp-content\/uploads\/2023\/07\/IMG_21531-300x300.jpg","caption":"Rafa\u0142 Bartoszak"},"description":"Wsp\u00f3\u0142pracuj\u0105cy z Botlandem elektronik, kt\u00f3ry dzieli si\u0119 swoj\u0105 wiedz\u0105 w internecie. Entuzjasta system\u00f3w cyfrowych, uk\u0142ad\u00f3w programowalnych i mikroelektroniki. Pasjonat historii, ze szczeg\u00f3lnym naciskiem na wiek XX.","url":"https:\/\/botland.de\/blog\/author\/rafal-bartoszak\/"}]}},"_links":{"self":[{"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/posts\/83432","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/users\/34"}],"replies":[{"embeddable":true,"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/comments?post=83432"}],"version-history":[{"count":0,"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/posts\/83432\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/media\/83424"}],"wp:attachment":[{"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/media?parent=83432"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/categories?post=83432"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/botland.de\/blog\/wp-json\/wp\/v2\/tags?post=83432"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}