برق و الکترونیک *دانلود پروژه رایگان

GregorianDate hijri_to_gregorian(HijriDate hDate) {
    uint32_t jdn = hijri_to_jdn(hDate);
    return jdn_to_gregorian(jdn);
}

// تابع ارسال رشته از طریق UART
void send_uart(char *str) {
    HAL_UART_Transmit(&huart2, (uint8_t*)str, strlen(str), HAL_MAX_DELAY);
}

// بازنویسی تابع `printf` برای UART
int _write(int file, char *ptr, int len) {
    HAL_UART_Transmit(&huart2, (uint8_t*)ptr, len, HAL_MAX_DELAY);
    return len;
}

// تابع اصلی
int main(void) {
    HAL_Init();
    SystemClock_Config();
    MX_USART2_UART_Init();

    // مثال ۱: تبدیل میلادی به هجری
    GregorianDate gregDate = {2023, 10, 7}; // تاریخ میلادی ورودی
    HijriDate hijriDate = gregorian_to_hijri(gregDate);
    printf("Gregorian: %04u-%02u-%02u => Hijri: %04u-%02u-%02u\r\n",
           gregDate.year, gregDate.month, gregDate.day,
           hijriDate.year, hijriDate.month, hijriDate.day);

    // مثال ۲: تبدیل هجری به میلادی
    HijriDate hijriInput = {1445, 3, 21}; // تاریخ هجری ورودی
    GregorianDate gregResult = hijri_to_gregorian(hijriInput);
    printf("Hijri: %04u-%02u-%02u => Gregorian: %04u-%02u-%02u\r\n",
           hijriInput.year, hijriInput.month, hijriInput.day,
           gregResult.year, gregResult.month, gregResult.day);

    while (1) {}
}

// ------------ توابع راه‌اندازی HAL ------------
void SystemClock_Config(void) {
    // پیکربندی کلاک (متناسب با MCU شما)
}

void MX_USART2_UART_Init(void) {
    huart2.Instance = USART2;
    huart2.Init.BaudRate = 115200;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    HAL_UART_Init(&huart2);
}

Gregorian: 2023-10-07 => Hijri: 1445-03-21
Hijri: 1445-03-21 => Gregorian: 2023-10-07

#include "main.h"
#include <stdio.h>
#include <stdint.h>

UART_HandleTypeDef huart2;

// تعریف ساختارهای تاریخ
typedef struct {
    uint16_t year;
    uint8_t month;
    uint8_t day;
} GregorianDate;

typedef struct {
    uint16_t year;
    uint8_t month;
    uint8_t day;
} HijriDate;

// آرایه سالهای کبیسه هجری (در چرخه 30 ساله)
const uint8_t hijriLeapYears[] = {1, 4, 6, 9, 12, 15, 17, 20, 23, 25, 28};

// --------- توابع تبدیل تاریخ ----------
// [همان توابع قبلی برای JDN و تبدیل تاریخ]
// ---------------------------------------

// تابع محاسبه JDN از میلادی
uint32_t gregorian_to_jdn(GregorianDate date) {
    uint16_t Y = date.year;
    uint8_t M = date.month;
    uint8_t D = date.day;
    return (1461 * (Y + 4800 + (M - 14)/12))/4 
           + (367 * (M - 2 - 12 * ((M -14)/12)))/12 
           - (3 * ((Y + 4900 + (M - 14)/12)/100))/4 
           + D 
           - 32075;
}

GregorianDate jdn_to_gregorian(uint32_t jdn) {
    GregorianDate date;
    uint32_t l = jdn + 68569;
    uint32_t n = (4 * l) / 146097;
    l = l - (146097 * n + 3) / 4;
    uint32_t i = (4000 * (l + 1)) / 1461001;
    l = l - (1461 * i) / 4 + 31;
    uint32_t j = (80 * l) / 2447;
    date.day = l - (2447 * j) / 80;
    l = j / 11;
    date.month = j + 2 - 12 * l;
    date.year = 100 * (n - 49) + i + l;
    return date;
}

uint32_t hijri_to_jdn(HijriDate date) {
    uint16_t year = date.year;
    uint8_t month = date.month;
    uint8_t day = date.day;
    uint32_t totalYears = year - 1;
    uint16_t cycles = totalYears / 30;
    uint16_t remainingYears = totalYears % 30;

    uint8_t leapCount = 0;
    for (uint8_t i = 0; i < remainingYears; i++) {
        for (uint8_t j = 0; j < 11; j++) {
            if (i == hijriLeapYears[j]) {
                leapCount++;
                break;
            }
        }
    }

    uint32_t totalLeapYears = cycles * 11 + leapCount;
    uint32_t totalDays = totalYears * 354 + totalLeapYears;

    uint16_t cyclePos = (year - 1) % 30;
    uint8_t isLeap = 0;
    for (uint8_t j = 0; j < 11; j++) {
        if (cyclePos == hijriLeapYears[j]) {
            isLeap = 1;
            break;
        }
    }

    uint8_t monthLengths[] = {30,29,30,29,30,29,30,29,30,29,30, isLeap ? 30 : 29};

    for (uint8_t m = 0; m < month - 1; m++) {
        totalDays += monthLengths[m];
    }

    totalDays += day - 1;
    return 1948440 + totalDays;
}

HijriDate jdn_to_hijri(uint32_t jdn) {
    HijriDate date;
    uint32_t daysSinceEpoch = jdn - 1948440;
    uint32_t totalDays = daysSinceEpoch;
    uint16_t year = 1;

    while (1) {
        uint16_t cyclePos = (year - 1) % 30;
        uint8_t isLeap = 0;
        for (uint8_t j = 0; j < 11; j++) {
            if (cyclePos == hijriLeapYears[j]) {
                isLeap = 1;
                break;
            }
        }
        uint32_t daysInYear = isLeap ? 355 : 354;
        if (totalDays >= daysInYear) {
            totalDays -= daysInYear;
            year++;
        } else {
            break;
        }
    }

    uint16_t cyclePos = (year - 1) % 30;
    uint8_t isLeap = 0;
    for (uint8_t j = 0; j < 11; j++) {
        if (cyclePos == hijriLeapYears[j]) {
            isLeap = 1;
            break;
        }
    }

    uint8_t monthLengths[] = {30,29,30,29,30,29,30,29,30,29,30, isLeap ? 30 : 29};
    uint8_t month, day;

    for (month = 1; month <= 12; month++) {
        uint8_t length = monthLengths[month - 1];
        if (totalDays < length) {
            day = totalDays + 1;
            break;
        }
        totalDays -= length;
    }

    date.year = year;
    date.month = month;
    date.day = day;
    return date;
}

HijriDate gregorian_to_hijri(GregorianDate gDate) {
    uint32_t jdn = gregorian_to_jdn(gDate);
    return jdn_to_hijri(jdn);
}

#include "main.h"

extern TIM_HandleTypeDef htim1;
extern DMA_HandleTypeDef hdma_tim1_ch1;

uint32_t pwmValues[5] = {200, 400, 600, 800, 1000}; // مقادیر متغیر برای PWM

void TIM1_PWM_DMA_Init(void) {
    // شروع انتقال داده از حافظه به تایمر با استفاده از DMA
    HAL_TIM_PWM_Start_DMA(&htim1, TIM_CHANNEL_1, pwmValues, 5);
}

int main(void) {
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_DMA_Init();
    MX_TIM1_Init();

    TIM1_PWM_DMA_Init(); // اجرای تابع مقداردهی اولیه

    while (1) {
        HAL_Delay(1000);
    }
}

#include "main.h"

extern TIM_HandleTypeDef htim2;
extern DMA_HandleTypeDef hdma_tim2_ch1;

uint32_t captureValues[10]; // آرایه ذخیره مقادیر ورودی

void TIM2_Capture_DMA_Init(void) {
    HAL_TIM_IC_Start_DMA(&htim2, TIM_CHANNEL_1, captureValues, 10);
}

int main(void) {
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_DMA_Init();
    MX_TIM2_Init();

    TIM2_Capture_DMA_Init(); // مقداردهی اولیه تایمر و DMA

    while (1) {
        HAL_Delay(1000);
    }
}

void Set_PWM_DutyCycle(uint32_t duty) {
    if (duty > 100) duty = 100;  // محدود کردن مقدار به 100%
    uint32_t compare_value = (1000 * duty) / 100;  // محاسبه مقدار مقایسه‌ای
    HAL_LPTIM_PWM_SetOnce(&hlptim1, 1000, compare_value);
}

void Start_LPTIM_ExternalCounter(void) {
    HAL_LPTIM_Counter_Start(&hlptim1, 0xFFFF); // شمارنده را روی مقدار حداکثر قرار می‌دهیم.
}

uint32_t Get_LPTIM_Count(void) {
    return HAL_LPTIM_ReadCounter(&hlptim1); // خواندن مقدار شمارش شده
}

ADC_HandleTypeDef hadc1;

void MX_ADC1_Init(void) {
    ADC_ChannelConfTypeDef sConfig = {0};

    /** تنظیمات اولیه ADC **/
    hadc1.Instance = ADC1;
    hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
    hadc1.Init.Resolution = ADC_RESOLUTION_12B;  // دقت اصلی 12 بیت
    hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
    hadc1.Init.ContinuousConvMode = ENABLE;
    hadc1.Init.DiscontinuousConvMode = DISABLE;
    hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    hadc1.Init.NbrOfConversion = 1;
    hadc1.Init.DMAContinuousRequests = DISABLE;
    hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
    HAL_ADC_Init(&hadc1);

    /** تنظیمات کانال ADC **/
    sConfig.Channel = ADC_CHANNEL_0;  // کانال 0 برای نمونه‌برداری
    sConfig.Rank = ADC_REGULAR_RANK_1;
    sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;
    HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}

void Configure_ADC_Oversampling(void) {
    ADC_OversamplingTypeDef sOversamplingConfig = {0};

    sOversamplingConfig.OversamplingMode = ENABLE;  // فعال‌سازی Oversampling
    sOversamplingConfig.RightBitShift = ADC_RIGHTBITSHIFT_4; // تقسیم مقدار کل به 16 (۲^۴)
    sOversamplingConfig.TriggeredMode = ADC_TRIGGEREDMODE_SINGLE_TRIGGER; // شروع با یک تریگر
    sOversamplingConfig.OversamplingStopReset = ADC_REGOVERSAMPLING_CONTINUED_MODE; // ادامه تبدیل‌ها

    sOversamplingConfig.OversamplingRatio = ADC_OVERSAMPLING_RATIO_16; // جمع‌آوری 16 نمونه

    HAL_ADCEx_OversamplingConfig(&hadc1, &sOversamplingConfig);
}

void Start_ADC(void) {
    HAL_ADC_Start(&hadc1);
    HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
    uint32_t adc_value = HAL_ADC_GetValue(&hadc1);
    
    printf("مقدار ADC با Oversampling: %lu\n", adc_value);
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int find_substrings(const char *str1, const char *str2, int **positions) {
    if (str1 == NULL || str2 == NULL) {
        *positions = NULL;
        return 0;
    }

    int len1 = strlen(str1);
    int len2 = strlen(str2);
    int count = 0;
    int i, j;

    // بررسی شرایطی که زیررشته نمیتواند وجود داشته باشد
    if (len2 == 0 || len1 < len2) {
        *positions = NULL;
        return 0;
    }

    // حداکثر تعداد ممکن موقعیتها
    int max_positions = len1 - len2 + 1;
    *positions = (int *)malloc(max_positions * sizeof(int));
    if (*positions == NULL) {
        return -1; // خطای تخصیص حافظه
    }

    // بررسی هر موقعیت ممکن در رشته اول
    for (i = 0; i <= len1 - len2; i++) {
        for (j = 0; j < len2; j++) {
            if (str1[i + j] != str2[j]) {
                break; // عدم تطابق، بررسی موقعیت بعدی
            }
        }
        if (j == len2) { // اگر تمام کاراکترها مطابقت داشتند
            (*positions)[count++] = i;
        }
    }

    // تنظیم مجدد اندازه آرایه به تعداد واقعی موقعیتهای یافت شده
    if (count == 0) {
        free(*positions);
        *positions = NULL;
    } else {
        int *temp = (int *)realloc(*positions, count * sizeof(int));
        if (temp != NULL) {
            *positions = temp;
        }
    }

    return count;
}

// مثال استفاده از تابع
int main() {
    const char *str1 = "ababa";
    const char *str2 = "aba";
    int *positions;
    int count = find_substrings(str1, str2, &positions);

    if (count > 0) {
        printf("تعداد تکرارها: %d\nموقعیتها: ", count);
        for (int i = 0; i < count; i++) {
            printf("%d ", positions[i]);
        }
        printf("\n");
        free(positions);
    } else {
        printf("زیررشته یافت نشد.\n");
    }

    return 0;
}

#include <stdio.h>
#include <string.h>

int findSubstring(const char *str1, const char *str2) {
    // اگر رشته دوم خالی باشد، موقعیت 0 برگردانده میشود
    if (*str2 == '\0') {
        return 0;
    }
    
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    
    // اگر طول رشته دوم از رشته اول بیشتر باشد، قطعا وجود ندارد
    if (len2 > len1) {
        return -1;
    }
    
    // بررسی تمام موقعیتهای ممکن در رشته اول
    for (int i = 0; i <= len1 - len2; i++) {
        // اگر کاراکتر اول تطابق داشت، بقیه را بررسی کن
        if (str1[i] == str2[0]) {
            int match = 1;
            for (int j = 1; j < len2; j++) {
                if (str1[i + j] != str2[j]) {
                    match = 0;
                    break;
                }
            }
            // اگر تمام کاراکترها تطابق داشتند
            if (match) {
                return i;
            }
        }
    }
    
    // اگر هیچ تطابقی یافت نشد
    return -1;
}

// مثال استفاده از تابع
int main() {
    const char *str1 = "hello world";
    const char *str2 = "world";
    
    int position = findSubstring(str1, str2);
    if (position != -1) {
        printf("زیررشته در موقعیت %d یافت شد.\n", position); // خروجی: 6
    } else {
        printf("زیررشته یافت نشد.\n");
    }
    
    return 0;
}

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* concatenate(const char* first, ...) {
    if (first == NULL) {
        char* result = malloc(1);
        if (result) *result = '\0';
        return result;
    }

    va_list args;
    size_t total_length = 0;
    const char* current = first;

    // محاسبه طول کل تمام رشته‌ها
    va_start(args, first);
    do {
        total_length += strlen(current);
        current = va_arg(args, const char*);
    } while (current != NULL);
    va_end(args);

    // اختصاص حافظه برای رشته نهایی
    char* result = (char*)malloc(total_length + 1);
    if (!result) return NULL;

    char* ptr = result;

    // الحاق رشته‌ها
    va_start(args, first);
    current = first;
    do {
        size_t len = strlen(current);
        memcpy(ptr, current, len);
        ptr += len;
        current = va_arg(args, const char*);
    } while (current != NULL);
    va_end(args);

    *ptr = '\0'; // پایان‌دهی رشته

    return result;
}

// مثال استفاده از تابع
int main() {
    char* str = concatenate("Hello", " ", "World!", NULL);
    if (str) {
        printf("%s\n", str); // خروجی: Hello World!
        free(str);
    }

    str = concatenate("C", " ", "Programming", " ", "Language", NULL);
    if (str) {
        printf("%s\n", str); // خروجی: C Programming Language
        free(str);
    }

    return 0;
}

---

### **۷. اشتباهات رایج**
#### خطا ۱: عدم استفاده از `&` برای متغیرها

#### خطا ۲: عدم تطابق فرمت و دادهها

int sscanf(const char *str, const char *format, ...);

#include <stdio.h>

int main() {
    char input[] = "42";
    int num;

    int result = sscanf(input, "%d", &num);

    printf("خوانده شده: %d\n", num); // خروجی: 42
    printf("تعداد متغیرهای خواندهشده: %d\n", result); // خروجی: 1

    return 0;
}

#include <stdio.h>

int main() {
    char input[] = "Ali 25 75.5";
    char name[50];
    int age;
    float score;

    int result = sscanf(input, "%s %d %f", name, &age, &score);

    printf("نام: %s\n", name);    // Ali
    printf("سن: %d\n", age);      // 25
    printf("امتیاز: %.1f\n", score); // 75.5
    printf("تعداد خواندهشده: %d\n", result); // 3

    return 0;
}

#include <stdio.h>

int main() {
    char input[] = "31/12/2023";
    int day, month, year;

    int result = sscanf(input, "%d/%d/%d", &day, &month, &year);

    printf("تاریخ: %d-%d-%d\n", day, month, year); // 31-12-2023
    printf("تعداد خواندهشده: %d\n", result); // 3

    return 0;
}

#include <stdio.h>

int main() {
    char input[] = "1234567890";
    char first_part[5];
    int num;

    // خواندن ۴ کاراکتر اول و سپس یک عدد
    sscanf(input, "%4s%d", first_part, &num);

    printf("بخش اول: %s\n", first_part); // 1234
    printf("عدد: %d\n", num);           // 567890

    return 0;
}

#include <stdio.h>

int main() {
    char input[] = "apple,banana,cherry";
    char fruits[3][20];

    // خواندن تا ویرگول
    sscanf(input, "%[^,],%[^,],%s", fruits[0], fruits[1], fruits[2]);

    printf("میوه ۱: %s\n", fruits[0]); // apple
    printf("میوه ۲: %s\n", fruits[1]); // banana
    printf("میوه ۳: %s\n", fruits[2]); // cherry

    return 0;
}

#include <stdio.h>

int main() {
    char input[] = "Product: 1234 Price: 99.99$";
    int id;
    float price;

    // نادیده گرفتن کلمه "Product:" و خواندن عدد
    sscanf(input, "Product: %d Price: %f$", &id, &price);

    printf("شناسه: %d\n", id);     // 1234
    printf("قیمت: %.2f\n", price); // 99.99

    return 0;
}

#include <stdio.h>

int main() {
    char input[] = "Error: Invalid Data";
    int code;

    int result = sscanf(input, "Error: %d", &code);

    if (result == 1) {
        printf("کد خطا: %d\n", code);
    } else {
        printf("فرمت رشته نادرست است!\n"); // این خط اجرا میشود
    }

    return 0;
}

#include <stdio.h>

int main() {
    char input[] = "Color: #FF5733";
    unsigned int color;

    sscanf(input, "Color: #%x", &color);

    printf("مقدار هگز: %X\n", color); // FF5733

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char** split(const char* str, char separator, int* count) {
    int len = strlen(str);
    int num_separators = 0;

    // شمارش تعداد جداکنندهها
    for (int i = 0; i < len; i++) {
        if (str[i] == separator) {
            num_separators++;
        }
    }

    // محاسبه تعداد توکنها
    int num_tokens = (len == 0) ? 0 : num_separators + 1;
    if (num_tokens == 0) {
        *count = 0;
        return NULL;
    }

    // ذخیره اندیسهای جداکنندهها
    int* separator_indices = malloc(num_separators * sizeof(int));
    if (!separator_indices) {
        return NULL;
    }

    int idx = 0;
    for (int i = 0; i < len; i++) {
        if (str[i] == separator) {
            separator_indices[idx++] = i;
        }
    }

    // اختصاص حافظه برای آرایه توکنها
    char** tokens = malloc((num_tokens + 1) * sizeof(char*));
    if (!tokens) {
        free(separator_indices);
        return NULL;
    }

    int token_index = 0;
    int start = 0;

    // استخراج توکنها بین جداکنندهها
    for (int i = 0; i < num_separators; i++) {
        int end = separator_indices[i] - 1;
        int token_length = end - start + 1;
        char* token = malloc(token_length + 1); // +1 برای نال ترمیناتور
        if (!token) {
            // آزادسازی حافظه در صورت خطا
            for (int j = 0; j < token_index; j++) {
                free(tokens[j]);
            }
            free(tokens);
            free(separator_indices);
            return NULL;
        }
        if (token_length > 0) {
            strncpy(token, str + start, token_length);
        }
        token[token_length] = '\0';
        tokens[token_index++] = token;
        start = separator_indices[i] + 1;
    }

    // آخرین توکن بعد از آخرین جداکننده
    int end = len - 1;
    int token_length = end - start + 1;
    char* token = malloc(token_length + 1);
    if (!token) {
        for (int j = 0; j < token_index; j++) {
            free(tokens[j]);
        }
        free(tokens);
        free(separator_indices);
        return NULL;
    }
    if (token_length > 0) {
        strncpy(token, str + start, token_length);
    }
    token[token_length] = '\0';
    tokens[token_index++] = token;

    // پایان آرایه با NULL
    tokens[token_index] = NULL;
    free(separator_indices);

    *count = num_tokens;
    return tokens;
}

// تابع برای آزاد کردن حافظه اختصاصدادهشده توسط split
void free_split_result(char** tokens) {
    if (tokens) {
        for (int i = 0; tokens[i] != NULL; i++) {
            free(tokens[i]);
        }
        free(tokens);
    }
}

// مثال استفاده از تابع
int main() {
    const char* str = "hello,,world";
    char separator = ',';
    int count;
    char** tokens = split(str, separator, &count);

    if (tokens) {
        printf("تعداد توکنها: %d\n", count);
        for (int i = 0; i < count; i++) {
            printf("توکن %d: '%s'\n", i, tokens[i]);
        }
        free_split_result(tokens);
    }

    return 0;
}

تعداد توکنها: 3
توکن 0: 'hello'
توکن 1: ''
توکن 2: 'world'

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* trim_string(const char* str, int n, int m) {
    if (str == NULL) {
        return NULL;
    }

    int len = strlen(str);
    
    // اطمینان از عدم منفی بودن n و m
    n = (n < 0) ? 0 : n;
    m = (m < 0) ? 0 : m;

    // محدود کردن n و m به طول رشته
    if (n > len) {
        n = len;
    }
    if (m > (len - n)) {
        m = len - n;
    }

    int new_len = len - n - m;
    char* result = (char*)malloc(new_len + 1); // +1 برای نال ترمیناتور
    if (result == NULL) {
        return NULL;
    }

    // کپی بخش مورد نظر از رشته اصلی
    memcpy(result, str + n, new_len);
    result[new_len] = '\0'; // پایان رشته

    return result;
}

// مثال استفاده از تابع
int main() {
    const char* str = "Hello, World!";
    int n = 3;
    int m = 4;
    
    char* trimmed = trim_string(str, n, m);
    if (trimmed != NULL) {
        printf("Original: %s\n", str);
        printf("Trimmed (%d from start, %d from end): '%s'\n", n, m, trimmed);
        free(trimmed); // آزادسازی حافظه
    }

    // تست موارد خاص
    char* test1 = trim_string("Example", 0, 0);
    printf("\nTest 1: '%s'\n", test1);
    free(test1);

    char* test2 = trim_string("Test", 5, 2);
    printf("Test 2: '%s'\n", test2);
    free(test2);

    char* test3 = trim_string("Hello", 1, 1);
    printf("Test 3: '%s'\n", test3);
    free(test3);

    return 0;
}

Original: Hello, World!
Trimmed (3 from start, 4 from end): 'lo, Wo'

Test 1: 'Example'
Test 2: ''
Test 3: 'ell'