WCH32v003 RISC-V MCU

[Atlan]

musiim zistit ci ide nejako zabranit vymazaniu dat, ktore su pouzite ako eeprom, mozno ulozenim do boot sektoru. (zatial to budem riesit odskrtnutim policka pri programovani: zmazat vsetko, ale stym mam zle skusenosti uvidime) prikladam zdrojak s zapisom do flash a checksum kontrolou.
Ak sa vykona nacitanie z flasheprom, a nesedi chceksum tak nahraje predvolene hodnoty.

[Atlan]

Zdravím tiež som začal s WCH32v003 ale mam trochu problem s nastavením a používaním prerušenia a používaním STANDBY módu- nemáte nejaké príklady použitia?

skus pozirt tu su nejake prikldy aj pre stndby
https://github.com/cnlohr/ch32v003fun/t ... r/examples

[burizon]

Lennox, ja len čumim. Večer sa rozhodneš, že ideš na C a ráno váliš ako profík. Len tak zmakneš one wire, pozrieš do datashetu DS3231, naprogramuješ, potom pozrieš na Oled ssd 1306 - naprogramuješ. Klobúk dolu.
A dielňu musíš mať tiež slušne vybavenú. Na "amatéra" a " hobistu" dobré.

[Lennox]

prikladam zdrojak s zapisom do flash a checksum kontrolou.
Ak sa vykona nacitanie z flasheprom, a nesedi chceksum tak nahraje predvolene hodnoty.

Pecka chlape Uz som aj skusobne implementoval do odmeriavania. Po stlaceni tlacidla zapise aktualnu hodnotu premennej ENC_Count do FlashEEPROM a pri starte nacita ulozenu hodnotu.
Takto viem zapisat do emulovanej EEPROM 63 32bit. premennych, ked som to spravne pochopil.

Kód: Vybrať všetko

//*******************************************************************************
// Enkoder 400 IPR odmeriavanie                                                 *
// Zobrazenie na i2C LCD Backpack i2c_adrs 0x40 - PCF8574T                      *                                                    *
//*******************************************************************************

#include "debug.h"
#include "i2c_lcd.h"
#include "Encoder.h"
#include "FlashEprom.h"

//*******************************************************************************
// Globalne premenne                                                            *
//*******************************************************************************
uint32_t milim = 0;
u_char GPIOInputStatus = 0;
//*******************************************************************************
// Aliasy                                                                       *
//*******************************************************************************
int Button = GPIO_Pin_3; // Tlacitko Port PD3
int LED    = GPIO_Pin_2; // LED
//*******************************************************************************
// Konfiguracia portov                                                          *
//*******************************************************************************
void GPIO_INIT(void){
    GPIO_InitTypeDef  GPIO_InitStructure = {0};
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE); // konfiguracia portu D
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;             // D3 vstup, tlacitko
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;         // internal pullup
    GPIO_Init(GPIOD, &GPIO_InitStructure);

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOD , ENABLE );
    GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_2;               // LED
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;         // vystup push pull
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;         // rychlost GPIO
    GPIO_Init(GPIOD, &GPIO_InitStructure);
}

//*******************************************************************************
// MAIN                                                                         *
//*******************************************************************************
int main(void){
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    SystemCoreClockUpdate();
    Delay_Init();
    GPIO_INIT();
    ENC_GPIO_INIT();
    IIC_Init( 80000, i2cadrs);
    lcd_init();

    LCD_BACKLIGHT = 0x08;

    F_eprom_read();     //0-data ok, 1-fail data corrupted, load default data
    ENC_Count = Set_value;

while(1){
    milim = (ENC_Count*20017)/10000; // 20017
    sprintf(str_val,"Dlzka: %d.%dmm    ",(milim/10),(milim)%10);
    lcd_set_cursor(0,0); lcd_string(str_val);
    sprintf(str_val,"Impulz: %d   ",ENC_Count);
    lcd_set_cursor(1,0); lcd_string(str_val);

    GPIOInputStatus = GPIO_ReadInputDataBit(GPIOD,Button); // nacitaj stav tlacitka na porte PD3
    if(GPIOInputStatus == 0){
    Set_value = ENC_Count;
    F_eprom_write();
    while (GPIOInputStatus == 0){ // zotrvaj v tejto slucke az pokial je stlacene tlacidlo
    GPIOInputStatus = GPIO_ReadInputDataBit(GPIOD,Button);
    Delay_Ms(100);
    }
   }
    Delay_Ms(10);
    }
}

Iba jedna maličkosť, kompilátor mrkotal s warningom, že vo funkcii uint8_t F_eprom_write(void)
nevraciaš žiadnu hodnotu.
Tak som doplnil return 0; na koniec funkcie. Včul je spokojný.

[Atlan]

Nezdasa mi to, mozno som omylom vymazal. Ale vidim ze tie hodnoty z returnu nepouzivas
Je ich tam viac koli zisteniu problemu 1 2 3, ale aspon 0 by bolo vhodne kontrolovat ze je to ok pri citani aj zapise.

Ale ked to funguje.

Toto by ma zaijimalo co stym urobi prekladac
int Button = GPIO_Pin_3;

Toto ide napisat
while(!GPIO_ReadInputDataBit(GPIOD,Button) ) Delay_Ms(100);

[Lennox]

Jasne, v "ostrej" prevádzke budem po zápise kontrolovať. Toto bola iba rýchla skúška pre overenie.
Keď vyčítam flash WCH-Linkom, tak je vidieť kde a čo zapisuje. Toto uchovávanie dát mi chýbalo. Teraz už iba dať pozor aby som zapisoval iba v nutnom prípade. Overiť, či zapisovaná hodnota je rôzna od už zapísanej a iba vtedy zapísať aby som zbytočne nedral flešku. Píšu niečo okolo 10tis. zápisov čo nie je až tak veľa.

[Lennox]

Toto by ma zaijimalo co stym urobi prekladac
int Button = GPIO_Pin_3;

Zdá sa že je s tým OK.

Toto ide napisat
while(!GPIO_ReadInputDataBit(GPIOD,Button) ) Delay_Ms(100);

mám sa čo ešte učiť.

Dokonca aj testovanie stlacenia tlacidla sa da prepisat na:

Kód: Vybrať všetko

   if(GPIO_ReadInputDataBit(GPIOD,Button) == 0){  // nacitaj stav tlacitka na porte PD3
    Set_value = ENC_Count;
    F_eprom_write();
    GPIO_SetBits(GPIOD,LED);
    Delay_Ms(100);
    GPIO_ResetBits(GPIOD,LED);
    Delay_Ms(100);
    GPIO_SetBits(GPIOD,LED);
    while(!GPIO_ReadInputDataBit(GPIOD,Button))Delay_Ms(100); // zotrvaj v tejto slucke az pokial je stlacene tlacidlo
    GPIO_ResetBits(GPIOD,LED);

Hodil som tam aj jednoduchy blikaci test pre overenie ci zapis vola iba raz.

[Atlan]

Nahrad toto: int Button = GPIO_Pin_3;

tymto #define button GPIO_Pin_3

Najprv to preloz tak ako to mas napisane, prekladac vypise zabranu ram a registre a flash.

Potom to nahrad define a daj znova prelozit, ci bude rozdiel v zabranej ram a registroch.

[Lennox]

Je tam rozdiel.
#define Button GPIO_Pin_3
text data bss dec hex filename
5648 64 548 6260 1874 Flash_EEPROM_CRC_v1.elf

int Button = GPIO_Pin_3;
text data bss dec hex filename
5660 72 548 6280 1888 Flash_EEPROM_CRC_v1.elf

Takze takto je mozne definovat aj LED, v tom pripade je to:
#define Button GPIO_Pin_3 // Tlacitko Port PD3
#define LED GPIO_Pin_2 // LED

text data bss dec hex filename
5620 64 548 6232 1858 Flash_EEPROM_CRC_v1.elf

[Atlan]

Ano lebo tvoje riesenie je : zober hodnotu pin3 a vloz ju do premenej typu int tj zaber jeden bajt v RAM. A potom stou premenou narabaj v programe

Kdez to define znamena ze button je to iste ako pin3 (nakoniec aj pin 3 je vlastne nejake cislo-konstanta) tj prekladac pri preklade ak narazi na button alebo pin3 pozera nato ako na rovnaku vec. (cize tam vlozi cislo ktore predstavuje pin3)

Citat si mozes tu https://spseke.sk/tutor/projekt/c_jazyk_dato.htm

[Atlan]

este ide pouzivat nieco take #define FUDO GPIOC, GPIO_Pin_5 //PC5

Mne to varovanie nepise.... Ale opravil som chyby pri verifikacii

Takto viem zapisat do emulovanej EEPROM 63 32bit. premennych.

63 lebo 0 je pouzita pre chceksum
Ano ale kludne mozes Fsize zvecsit na nasobky 64 lebo zapisuje sa po strankach, a nasledne upravit aj Fadr - znizit patricne hodnotu aby ti to voslo vsetko az po koniec flash.

Kód: Vybrať všetko

/*
 * FlashEprom.c
 *
 *  Created on: Mar 18, 2024
 *      Author: Atlan
 */
#include <ch32v00x.h>
#include "FlashEprom.h"

#define Fadr    0x08003f00      //0x08003000
#define Fsize   64              //64pcs - 32bit variable
u_int32_t F_eprom_buffer[Fsize];

//***************************************************************************************
//---------------------------------------------------------------------------------------
//***************************************************************************************
uint8_t F_eprom_read(void)
{
    u_int32_t   i;
    u_int32_t   checksum = 0;

    //Read flash to buffer
    for(i=0; i<Fsize; i++){F_eprom_buffer[i] = (*(u32*)(Fadr +4*i));}

    //Calculate a checksum over the loaded data
    for(i=1;i<Fsize;i++)
    {
      checksum += F_eprom_buffer[i];
    }

    if(F_eprom_buffer[0] == checksum)
    {
    //------------------------------------------------------------
        //copy value from buffer to variable (1-63)
        Set_value = F_eprom_buffer[1];


        //Set_value1 = F_eprom_buffer[63];

    //------------------------------------------------------------
        return 0;   // 0-data ok
    }
    else
    {
    //************************************************************
        // this is place to default data
        Set_value = 99;



    //************************************************************
        return 1;    // 1-fail,data corrupted, load default data
    }
}

//***************************************************************************************
//---------------------------------------------------------------------------------------
//***************************************************************************************
uint8_t F_eprom_write(void)
{
    u_int32_t i;
    u_int32_t   checksum = 0;
    FLASH_Status s;
//---------------------------------------------------------------------
    //copy value variable to buffer (1-63)
    F_eprom_buffer[1] = Set_value;

    //F_eprom_buffer[63] = 0x01010101;

//---------------------------------------------------------------------
    //Calculate a checksum over the buffer data
    for(i=1;i<Fsize;i++)
    {
        checksum += F_eprom_buffer[i];
    }

    //Save the checksum
    F_eprom_buffer[0] = checksum;

    // FLASH erase
    s = FLASH_ROM_ERASE(Fadr, Fsize*4);
    if(s != FLASH_COMPLETE)
    {
        return 1;      // 1-fail,erase flash ERROR
    }
    // FLASH write
    s = FLASH_ROM_WRITE(Fadr,  F_eprom_buffer, Fsize*4);
    if(s != FLASH_COMPLETE)
    {
        return 2;       // 2-fail,write flash ERROR
    }
       // FLASH verify
    for(i = 0; i < Fsize; i++)
    {
        if(F_eprom_buffer[i] != *(u32 *)(Fadr + 4 * i))
        {
            return 3;     // 3-fail verify
            break;
        }
    }
    return 0;
}
//***************************************************************************************

dufam ze toto v prilohe je uz ok

[Atlan]

Keď vyčítam flash WCH-Linkom, tak je vidieť kde a čo zapisuje. Toto uchovávanie dát mi chýbalo. Teraz už iba dať pozor aby som zapisoval iba v nutnom prípade. Overiť, či zapisovaná hodnota je rôzna od už zapísanej a iba vtedy zapísať aby som zbytočne nedral flešku.

Tak davaj pozor lebo nahravanim programu tiez deries flesku, ked sa onu bojis za 2centy je eprom i2c (ked uz tam mas pripojeny disolej na i2c tak doplnit eprom je bagatel)

Overovat roznu hodnotu nemusis. Lebo zapis do flash sa vykona tak ci tak.

Najprv sa flash zmaze, a potom nanovo cela zapise.

[balu]

Pozor na drobné rozdíly mezi

Kód: Vybrať všetko

int Button = GPIO_Pin_3;

a

Kód: Vybrať všetko

int Button;
Button = GPIO_Pin_3;

V prvním přpadě proměnnou Button nadefinuješ (vyhradíš pro ní paměťové místo) a zinicializuješ (nastavíš na danou hodnotu), ale pak už do ní hodnotu z pinu GPIO_Pin_3 nenačítáš - to je jenom inicializace proměnné při deklaraci - ta se provádí jen jednou.

Ve druhém případě proměnnou Button nadefinuješ (vyhradíš pro ní paměťové místo => int Button;) a zápis hodnoty (Button = GPIO_Pin_3;) je pak už součástí programu - takže opakovaně při provádění tohoto příkazu.

[Lennox]

Tak davaj pozor lebo nahravanim programu tiez deries flesku, ked sa onu bojis za 2centy je eprom i2c (ked uz tam mas pripojeny disolej na i2c tak doplnit eprom je bagatel)

Ale nebojím sa o ňu. Ide iba o to aby som neurobil chybu v programe a bude do flashky zapisovať periodicky, však vieš čo myslím.

Teraz sa akurát snažím rozbehať PID reguláciu DC motora. Feedback je optický enkodér, H-mostík ako driver motora. PWM hw perifériou MCU, enkodér čítam v prerušení, pre PID algoritmus používam SysTick counter napísal som rutinu niečo ako millis() známe z Arduina.
Inšpiroval som sa tu: http://brettbeauregard.com/blog/2011/04 ... roduction/

[Atlan]

Ext int0 pre impulzi z encidera
Timer napr 1ms a vnom nacitat pocet napocitanich pulzov z premenej ext int0.
Vlozid do rovnice PID vysledok vlozit do pwm. Nastavit spravne kP a kD hodnoty. Jednoduché ze

[Lennox]

Tak nejak. Dnes som mal cas sa tomu venovat. Chvilu mi trvalo prist na to ako nakonfigurovat PWM TIM1 samostatne pre kanal3 a kanal4 aby som mohol generovat PWM pre CW CCW (smer otacanie motora).
Nakolko pouzity Hmost ma iba dva vstupy a to cw a ccw. Zaroven je to aj vstup pre PWM.
Nakoniec teda takto:

Kód: Vybrať všetko

//*******************************************************************************
// Konfiguracia PWM Timer1, CH3, CH4                                            *
//*******************************************************************************
void TIM1_CH4_PWMOut_Init(u16 arr, u16 psc, u16 ccp)
{
    GPIO_InitTypeDef GPIO_InitStructure={0};
    TIM_OCInitTypeDef TIM_OCInitStructure={0};
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure={0};

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC, ENABLE );
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_Init( GPIOC, &GPIO_InitStructure );

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_TIM1, ENABLE );
    TIM_TimeBaseInitStructure.TIM_Period = arr;
    TIM_TimeBaseInitStructure.TIM_Prescaler = psc;
    TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit( TIM1, &TIM_TimeBaseInitStructure);

    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;

    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    TIM_OCInitStructure.TIM_Pulse = ccp;
    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    TIM_OC4Init( TIM1, &TIM_OCInitStructure );


    TIM_CtrlPWMOutputs(TIM1, ENABLE );
    TIM_OC4PreloadConfig( TIM1, TIM_OCPreload_Disable );
    TIM_ARRPreloadConfig( TIM1, ENABLE );
    TIM_Cmd( TIM1, ENABLE );
}

void TIM1_CH3_PWMOut_Init(u16 arr, u16 psc, u16 ccp)
{
    GPIO_InitTypeDef GPIO_InitStructure={0};
    TIM_OCInitTypeDef TIM_OCInitStructure={0};
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure={0};

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC, ENABLE );
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_Init( GPIOC, &GPIO_InitStructure );

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_TIM1, ENABLE );
    TIM_TimeBaseInitStructure.TIM_Period = arr;
    TIM_TimeBaseInitStructure.TIM_Prescaler = psc;
    TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit( TIM1, &TIM_TimeBaseInitStructure);

    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;

    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    TIM_OCInitStructure.TIM_Pulse = ccp;
    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    TIM_OC3Init( TIM1, &TIM_OCInitStructure );


    TIM_CtrlPWMOutputs(TIM1, ENABLE );
    TIM_OC3PreloadConfig( TIM1, TIM_OCPreload_Disable );
    TIM_ARRPreloadConfig( TIM1, ENABLE );
    TIM_Cmd( TIM1, ENABLE );
}

No a potom uz len dosadit do PWM:

Kód: Vybrať všetko

// Check error and adjust motor direction
            if (ENC_Count < target) {
                TIM1_CH4_PWMOut_Init(254, 100-1, output);
                TIM1_CH3_PWMOut_Init(254, 100-1, 0);
            }
               if (ENC_Count > target) {
                TIM1_CH3_PWMOut_Init(254, 100-1, output);
                TIM1_CH4_PWMOut_Init(254, 100-1, 0);
            }

Dalo viac zabrat nastavit spravne PID parametre Kp, Kd, Ki

Ked som kukol do mojho stareho PID kodu v PIC Basicu a rutinu prerusenia a citania Enkoderu v ASM tak ma oblieva studeny pot.

[Lennox]

Potreboval som generator signalu pre dve RC serva nezavisle na sebe v vacsim rozsahom ako klasika 1000us do 2000us. Tak preco nepouzit tento mikrokontroler. Som prekvapeny ako presne ide generovat pouzitim vstavanej periferie signal. Obnovovacia frekvencia 50Hz, perioda pozadovana 20ms, sirka pulzu rozcirena od 900us do 2300us. Signal generujem timerom TIM1 na kanale 1 a 2. Teoreticky dokazem obsluhovat nezavisle az 8. serv bez toho aby som napisal co i len riadok do hlavnej slucky. No paci sa mi to cim dalej tym viac
Tu je kratke video ako to fici:
https://www.youtube.com/watch?v=FoHI8v_iR0c
ps. Atlan diky za pracu na 1013 je to pecka

[Lennox]

Rad by som sa opytal skusenejsich C-ckarov. Snazim sa prekusat cez pointre a referencie.
Napisal som jednoduchy program ktory vypisuje hodnoty premennych x, y na LCD pomocou pointra.
Program funguje, ovsem rad by som vedel, ci taketo pouzitie pointra a referencie je OK.

Kód: Vybrať všetko

#include "debug.h"
#include "i2c_LCD.h"

u_char str_val[16];

   // rutina na vypis na LCD
    void Print_On_Lcd (int *ptr){
    sprintf(str_val,"VAR=%3d",*ptr);
    LCD_PrintXY(0, 0,str_val);
    }

int main(void){
    SystemCoreClockUpdate();
    Delay_Init();
    LCD_Config();

    int x = 800; // zapis do premennej x hodnotu 800 dec
    int y = 13;  // zapis do premennej y hodnotu  13 dec

    while(1){
    Print_On_Lcd(&x); // vypis na LCD hodnotu premennej x (referencia na x)
    Delay_Ms(2000);
    Print_On_Lcd(&y); // vypis na LCD hodnotu premennej y (referencia na y)
    Delay_Ms(2000);
   }
}

EDIT: rutina na vypis na LCD dana mimo main.

[budvar10]

Aký kompilátor? Definovať funkciu vo funkcii nie je asi vporiadku. Print_On_Lcd máš v main().

Pointer a referenciu máš správne.

Aj tak som prekvapený otázkou. S Atlanom tu dávate také veci. Toto sa mi na teba zdá triviálne.

[Lennox]

Aký kompilátor? Definovať funkciu vo funkcii nie je asi vporiadku. Print_On_Lcd máš v main().
Pointer a referenciu máš správne.

Dakujem za upozornenie. Som to kopiroval z mojho testovacieho kodu a vynechaval som balast tak som to omylom strihol do mainu. Upravil som to aby to nemiatlo osadenstvo.
Kompilator je RISC-V Embedded GCC.

Aj tak som prekvapený otázkou. S Atlanom tu dávate také veci. Toto sa mi na teba zdá triviálne.

Zdanie moze klamat, s Cckom iba zacinam vid. toto vlakno. Este zaciatkom roka som o tomto jazyku vedel iba to ze existuje.

Tou definiciou funkcie vo funkcii myslis to , ze z rutiny Print_On_Lcd volam LCD_PrintXY?
To by sa nemalo?