CalvinBackup/Embedded-Hacking
1
0
Fork 0
mirror of https://github.com/mytechnotalent/Embedded-Hacking.git synced 2026-05-17 21:44:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

style: enforce coding standard — headers, @brief on #define, Doxygen on statics, remove _ prefix, max 8 lines per function

Browse Source
This commit is contained in:
Kevin Thomas
2026-04-16 22:44:43 -04:00
parent 0833c32c94
commit 433263eac0
309 changed files with 10464 additions and 6668 deletions
Download Patch File Download Diff File Expand all files Collapse all files
0x0023_structures/0x0023_structures.c
+120 -41
View File
@@ -1,8 +1,50 @@
/**
* @file 0x0023_structures.c
* @brief Structures: IR remote controls LEDs via a struct-based controller
* @author Kevin Thomas
* @date 2025
*
* MIT License
*
* Copyright (c) 2025 Kevin Thomas
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* -----------------------------------------------------------------------------
*
* Demonstrates C structures by defining a simple_led_ctrl_t to manage three
* LEDs. An IR receiver on GPIO5 decodes NEC commands and activates the
* corresponding LED (0x0C -> GPIO16, 0x18 -> GPIO17, 0x5E -> GPIO18).
*
* Wiring:
* GPIO5 -> IR receiver OUT
* GPIO16 -> LED1 anode (with current-limiting resistor to GND)
* GPIO17 -> LED2 anode (with current-limiting resistor to GND)
* GPIO18 -> LED3 anode (with current-limiting resistor to GND)
*/
#include <stdio.h>
#include <stdbool.h>
#include "pico/stdlib.h"
#include "ir.h"
/** @brief GPIO pin number for the IR receiver */
#define IR_PIN 5
typedef struct {
@@ -14,48 +56,85 @@ typedef struct {
bool led3_state;
} simple_led_ctrl_t;
int main(void) {
stdio_init_all();
/**
* @brief Initialize all three LED GPIO pins as outputs
*
* @details Configures led1_pin, led2_pin, and led3_pin from the
* structure as GPIO outputs.
*
* @param leds pointer to the LED controller structure
* @retval None
*/
static void init_led_gpios(simple_led_ctrl_t *leds) {
gpio_init(leds->led1_pin);
gpio_set_dir(leds->led1_pin, GPIO_OUT);
gpio_init(leds->led2_pin);
gpio_set_dir(leds->led2_pin, GPIO_OUT);
gpio_init(leds->led3_pin);
gpio_set_dir(leds->led3_pin, GPIO_OUT);
}
simple_led_ctrl_t leds = {
.led1_pin = 16,
.led2_pin = 17,
.led3_pin = 18,
.led1_state = false,
.led2_state = false,
.led3_state = false
};
/**
* @brief Process an NEC IR key and update LED states
*
* @details Maps NEC command codes to LEDs: 0x0C -> LED1, 0x18 -> LED2,
* 0x5E -> LED3. Turns off all LEDs first, then activates the match.
*
* @param leds pointer to the LED controller structure
* @param key NEC command code from IR receiver
* @retval None
*/
static void process_ir_key(simple_led_ctrl_t *leds, int key) {
printf("NEC command: 0x%02X\n", key);
leds->led1_state = (key == 0x0C);
leds->led2_state = (key == 0x18);
leds->led3_state = (key == 0x5E);
gpio_put(leds->led1_pin, leds->led1_state);
gpio_put(leds->led2_pin, leds->led2_state);
gpio_put(leds->led3_pin, leds->led3_state);
sleep_ms(10);
}
gpio_init(leds.led1_pin); gpio_set_dir(leds.led1_pin, GPIO_OUT);
gpio_init(leds.led2_pin); gpio_set_dir(leds.led2_pin, GPIO_OUT);
gpio_init(leds.led3_pin); gpio_set_dir(leds.led3_pin, GPIO_OUT);
ir_init(IR_PIN);
printf("IR receiver on GPIO %d ready\n", IR_PIN);
while (true) {
int key = ir_getkey();
if (key >= 0) {
printf("NEC command: 0x%02X\n", key);
// turn all off first
leds.led1_state = false;
leds.led2_state = false;
leds.led3_state = false;
// check NEC codes
if (key == 0x0C) leds.led1_state = true; // GPIO16
if (key == 0x18) leds.led2_state = true; // GPIO17
if (key == 0x5E) leds.led3_state = true; // GPIO18
// apply states
gpio_put(leds.led1_pin, leds.led1_state);
gpio_put(leds.led2_pin, leds.led2_state);
gpio_put(leds.led3_pin, leds.led3_state);
sleep_ms(10);
} else {
sleep_ms(1);
}
/**
* @brief Poll IR receiver and dispatch key to handler
*
* @details Reads one IR key; if valid, processes it; otherwise
* yields with a short sleep.
*
* @param leds pointer to the LED controller structure
* @retval None
*/
static void poll_ir(simple_led_ctrl_t *leds) {
int key = ir_getkey();
if (key >= 0) {
process_ir_key(leds, key);
} else {
sleep_ms(1);
}
}
/**
* @brief Build the default LED controller structure
*
* @details Initializes pins 16-18 with all LEDs off.
*
* @return simple_led_ctrl_t initialized structure
*/
static simple_led_ctrl_t make_default_leds(void) {
simple_led_ctrl_t leds = {
.led1_pin = 16, .led2_pin = 17, .led3_pin = 18,
.led1_state = false, .led2_state = false, .led3_state = false
};
return leds;
}
int main(void) {
stdio_init_all();
simple_led_ctrl_t leds = make_default_leds();
init_led_gpios(&leds);
ir_init(IR_PIN);
printf("IR receiver on GPIO %d ready\n", IR_PIN);
while (true) {
poll_ir(&leds);
}
}
0x0023_structures/ir.c
+76 -26
View File
@@ -32,19 +32,89 @@
#include "pico/time.h"
#include "hardware/gpio.h"
/** @brief GPIO pin connected to the IR receiver */
static unsigned int ir_pin = 0;
// Wait for 'gpio' to reach 'level' or timeout (microseconds). Return elapsed us or -1.
/**
* @brief Wait for a GPIO pin to reach a given logic level
*
* Spins until the pin matches the requested level or a microsecond timeout
* is exceeded. Returns the elapsed time in microseconds, or -1 on timeout.
*
* @param gpio GPIO pin to monitor
* @param level Desired logic level (true = HIGH, false = LOW)
* @param timeout_us Maximum wait in microseconds
* @return int64_t Elapsed microseconds, or -1 on timeout
*/
static int64_t wait_for_level(unsigned int gpio, bool level, uint32_t timeout_us) {
absolute_time_t start = get_absolute_time();
while (gpio_get(gpio) != level) {
if (absolute_time_diff_us(start, get_absolute_time()) > (int64_t)timeout_us) {
if (absolute_time_diff_us(start, get_absolute_time()) > (int64_t)timeout_us)
return -1;
}
}
return absolute_time_diff_us(start, get_absolute_time());
}
/**
* @brief Wait for the NEC 9 ms leader pulse and 4.5 ms space
*
* @return bool true if a valid leader was detected, false on timeout
*/
static bool wait_leader(void) {
if (wait_for_level(ir_pin, 0, 150000) < 0) return false;
int64_t t = wait_for_level(ir_pin, 1, 12000);
if (t < 8000 || t > 10000) return false;
t = wait_for_level(ir_pin, 0, 7000);
if (t < 3500 || t > 5000) return false;
return true;
}
/**
* @brief Read a single NEC-encoded bit from the IR receiver
*
* Measures the mark/space timing and shifts the result into the
* appropriate byte of the data array.
*
* @param data 4-byte array accumulating received bits
* @param i Bit index (0-31)
* @return bool true on success, false on timeout or protocol error
*/
static bool read_nec_bit(uint8_t *data, int i) {
if (wait_for_level(ir_pin, 1, 1000) < 0) return false;
int64_t t = wait_for_level(ir_pin, 0, 2500);
if (t < 200) return false;
int byte_idx = i / 8;
int bit_idx = i % 8;
if (t > 1200) data[byte_idx] |= (1 << bit_idx);
return true;
}
/**
* @brief Read all 32 data bits of an NEC frame
*
* @param data 4-byte array filled with the received address and command
* @return bool true if all 32 bits were read, false on timeout
*/
static bool read_32_bits(uint8_t *data) {
for (int i = 0; i < 32; ++i)
if (!read_nec_bit(data, i)) return false;
return true;
}
/**
* @brief Validate an NEC frame and extract the command byte
*
* Checks that the address and command pairs are bitwise-inverted.
*
* @param data 4-byte NEC frame (addr, ~addr, cmd, ~cmd)
* @return int Command byte (0-255) on success, -1 on validation failure
*/
static int validate_nec_frame(const uint8_t *data) {
if ((uint8_t)(data[0] + data[1]) == 0xFF && (uint8_t)(data[2] + data[3]) == 0xFF)
return data[2];
return -1;
}
void ir_init(uint8_t pin) {
ir_pin = pin;
gpio_init(pin);
@@ -53,28 +123,8 @@ void ir_init(uint8_t pin) {
}
int ir_getkey(void) {
// leader low (~9 ms)
if (wait_for_level(ir_pin, 0, 150000) < 0) return -1;
int64_t t = wait_for_level(ir_pin, 1, 12000);
if (t < 8000 || t > 10000) return -1;
t = wait_for_level(ir_pin, 0, 7000);
if (t < 3500 || t > 5000) return -1;
if (!wait_leader()) return -1;
uint8_t data[4] = {0, 0, 0, 0};
for (int i = 0; i < 32; ++i) {
if (wait_for_level(ir_pin, 1, 1000) < 0) return -1;
t = wait_for_level(ir_pin, 0, 2500);
if (t < 200) return -1;
int byte_idx = i / 8;
int bit_idx = i % 8;
if (t > 1200) data[byte_idx] |= (1 << bit_idx); // logical '1'
}
// Validate address/data inverted pairs
if ((uint8_t)(data[0] + data[1]) == 0xFF && (uint8_t)(data[2] + data[3]) == 0xFF) {
return data[2];
}
return -1;
if (!read_32_bits(data)) return -1;
return validate_nec_frame(data);
}