flask怎么定义一个全局变量

在 Flask 中定义全局变量有两种常用的方式：

1. 使用应用程序实例的 `config` 对象定义全局变量，如下所示：

   app = Flask(__name__)
   app.config['MY_GLOBAL_VAR'] = 'my global variable'

然后你就可以在应用程序的其他地方使用 `app.config['MY_GLOBAL_VAR']` 访问这个变量了。

2. 使用 Flask 中的 `g` 对象定义全局变量，如下所示：

   from flask import g

   @app.before_request
   def before_request():
       g.my_global_var = 'my global variable'

此时 `g.my_global_var` 就是一个全局变量，可以在应用程序的其他地方使用。

需要注意的是，使用 `config` 对象定义的全局变量是应用程序级别的，而使用 `g` 对象定义的全局变量是请求级别的，即一个请求中的 `g` 对象不能访问另一个请求中的 `g` 对象定义的全局变量。

相关问题

安卓内核内如何在关机的时候保存一个变量，开机时再获取

在安卓内核中，在关机时保存一个变量，开机时再获取，可以通过以下步骤实现：

1. 定义一个需要保存的变量，可以通过定义全局变量或者定义一个驱动的属性来实现。

2. 在系统关机时，将变量的值保存到一个持久化存储介质中，比如说硬盘、eMMC、NAND Flash等。

3. 在系统开机时，从持久化存储介质中读取变量的值，并将其设置到内核中。

具体实现可以参考以下步骤：

1. 定义需要保存的变量

可以在内核中定义一个全局变量，比如说：

static int shutdown_var;

或者定义一个驱动属性：

static DEVICE_ATTR(shutdown_var, 0644, my_show, my_store);

2. 在系统关机时保存变量的值

可以使用系统关机时的钩子函数来保存变量的值，比如说：

static int my_shutdown(struct notifier_block *nb, unsigned long action, void *data)
{
    struct file *fp;
    int ret;
    char buf[20];

    fp = filp_open("/data/shutdown_var", O_WRONLY | O_CREAT, 0644);
    if (IS_ERR(fp)) {
        return PTR_ERR(fp);
    }

    snprintf(buf, sizeof(buf), "%d\n", shutdown_var);
    ret = kernel_write(fp, buf, strlen(buf), 0);
    filp_close(fp, NULL);

    return ret;
}

static struct notifier_block my_notifier_block = {
    .notifier_call = my_shutdown,
};

在上面的例子中，我们将变量的值写入到了`/data/shutdown_var`文件中。

3. 在系统开机时获取变量的值

可以在驱动的初始化函数中从持久化存储介质中读取变量的值，比如说：

static int my_driver_probe(struct platform_device *pdev)
{
    struct file *fp;
    char buf[20];
    int ret;

    fp = filp_open("/data/shutdown_var", O_RDONLY, 0);
    if (IS_ERR(fp)) {
        return PTR_ERR(fp);
    }

    ret = kernel_read(fp, buf, sizeof(buf), 0);
    filp_close(fp, NULL);

    if (ret > 0) {
        shutdown_var = simple_strtol(buf, NULL, 10);
    }

    return 0;
}

在上面的例子中，我们从`/data/shutdown_var`文件中读取变量的值，并将其设置到全局变量`shutdown_var`中。

需要注意的是，在执行读写文件的操作时，需要确保持久化存储介质已经被挂载并且可用。

STM32F103使用内部Flash保存参数

在STM32F103系列芯片中，内部Flash可用于存储非易失性数据，例如配置参数、校准值等。以下是使用内部Flash保存参数的一般步骤：

1. 定义一个结构体来存储需要保存的参数。

   typedef struct {
       uint32_t parameter1;
       uint32_t parameter2;
       // ...
   } ParameterTypeDef;

2. 定义一个指针变量，指向Flash中存储参数的起始地址。

   #define PARAMETER_ADDRESS 0x0800F800 // 定义Flash地址，最后一页
   ParameterTypeDef *parameter = (ParameterTypeDef *)PARAMETER_ADDRESS;

3. 在初始化时读取Flash中存储的参数。

   void Init(void) {
       // 读取Flash中保存的参数
       if (FLASH_OB_GetUser() == 0xFFFFFFFF) {
           // 第一次运行，参数未存储
           parameter->parameter1 = DEFAULT_PARAMETER1;
           parameter->parameter2 = DEFAULT_PARAMETER2;
           // ...
           SaveParameter();
       }
       else {
           // 参数已存储，从Flash中读取
           memcpy(parameter, (void *)PARAMETER_ADDRESS, sizeof(ParameterTypeDef));
       }
   }

4. 在需要更新参数时，先更新结构体中的值，然后保存到Flash中。

   void UpdateParameter(uint32_t newParameter1, uint32_t newParameter2) {
       parameter->parameter1 = newParameter1;
       parameter->parameter2 = newParameter2;
       // ...
       SaveParameter();
   }

5. 参数保存到Flash的函数。

   void SaveParameter(void) {
       // 禁止全局中断
       __disable_irq();
       // 解锁Flash并擦除最后一页
       FLASH_Unlock();
       FLASH_ErasePage(PARAMETER_ADDRESS);
       // 写入参数到Flash
       uint32_t *p = (uint32_t *)parameter;
       for (uint32_t i = 0; i < sizeof(ParameterTypeDef) / 4; i++) {
           FLASH_ProgramWord(PARAMETER_ADDRESS + i * 4, *(p + i));
       }
       // 锁定Flash
       FLASH_Lock();
       // 使能全局中断
       __enable_irq();
   }

需要注意的是，使用内部Flash存储参数时，需要考虑Flash的擦写次数限制，因此应尽量避免频繁的更新操作。