【驱动篇】龙芯LS2K0300之单总线驱动

已于 2024-08-20 10:51:44 修改
阅读量783 收藏 6
点赞数 18
分类专栏： LS2K0300 文章标签： LS2K0300 龙芯 久久派 LoongArch
于 2024-06-23 22:33:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HeavenMo/article/details/139907775
版权

实验过程

实验目的： 在龙芯开发板上面使用单总线驱动DS18B20温度传感器

① 根据原理图连接DS18B20模块

② 将i2c0引脚的功能复用为GPIO

③ 注册字符设备，按照DS18B20的读写时序编写读写驱动接口

④ 编写测试用例解析传感器的数值

原理图

将板子上面的GPIO48连接传感器的DAT引脚，其余引脚连接如下

在这里插入图片描述

然后记得在设备树中把i2c0部分代码注释掉，将PIN16复用为GPIO48

驱动代码

定义相关传感器设备结构体

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/errno.h>

#define DS18B20_DEV_NUM			1		  
#define DS18B20_DEV		        "ds18b20"	
#define DS18B20_GPIO            48
#define DS18B20_DQ_OUT(x)       gpio_direction_output(ds18b20.gpio, x)
#define DS18B20_DQ_IN           ds18b20_get_io()

struct ds18b20_dev {
    dev_t dev_id;		
	struct cdev cdev;	
	struct class *class;	
	struct device *device;	
	int major;			
	int minor;	
    int gpio;				
    unsigned char data[2]; 
	struct timer_list timer;	
    struct work_struct work;
};

struct ds18b20_dev ds18b20;

传感器数据读写交互

static int ds18b20_get_io(void)
{
    gpio_direction_input(ds18b20.gpio);
    return gpio_get_value(ds18b20.gpio); 
}

static void ds18b20_reset(void)
{
    DS18B20_DQ_OUT(0);  /* 拉低DQ,复位 */
    udelay(750);      /* 拉低750us */
    DS18B20_DQ_OUT(1);  /* DQ=1, 释放复位 */
    udelay(15);       /* 延迟15US */
}

uint8_t ds18b20_check(void)
{
    uint8_t retry = 0;
    uint8_t rval = 0;

    while (DS18B20_DQ_IN && retry < 200)    /* 等待DQ变低, 等待200us */
    {
        retry++;
        udelay(1);
    }

    if (retry >= 200)
    {
        rval = 1;
    }
    else
    {
        retry = 0;

        while (!DS18B20_DQ_IN && retry < 240)   /* 等待DQ变高, 等待240us */
        {
            retry++;
            udelay(1);
        }

        if (retry >= 240) rval = 1;
    }

    return rval;
}

static uint8_t ds18b20_read_bit(void)
{
    uint8_t data = 0;
    DS18B20_DQ_OUT(0);
    udelay(2);
    DS18B20_DQ_OUT(1);
    udelay(12);

    if (DS18B20_DQ_IN)
    {
        data = 1;
    }

    udelay(50);
    return data;
}

static uint8_t ds18b20_read_byte(void)
{
    uint8_t i, b, data = 0;

    for (i = 0; i < 8; i++)
    {
        b = ds18b20_read_bit(); /* DS18B20先输出低位数据 ,高位数据后输出 */

        data |= b << i;         /* 填充data的每一位 */
    }

    return data;
}

static void ds18b20_write_byte(uint8_t data)
{
    uint8_t j;
    for (j = 1; j <= 8; j++)
    {
        if (data & 0x01)
        {
            DS18B20_DQ_OUT(0);  /*  Write 1 */
            udelay(2);
            DS18B20_DQ_OUT(1);
            udelay(60);
        }
        else
        {
            DS18B20_DQ_OUT(0);  /*  Write 0 */
            udelay(60);
            DS18B20_DQ_OUT(1);
            udelay(2);
        }

        data >>= 1;             /* 右移,获取高一位数据 */
    }
}

static void ds18b20_start(void)
{
    ds18b20_reset();
    ds18b20_check();
    ds18b20_write_byte(0xcc);   /*  skip rom */
    ds18b20_write_byte(0x44);   /*  convert */
}

static int ds18b20_init(void)
{
    gpio_direction_output(ds18b20.gpio, 0);
    ds18b20_reset();
    return ds18b20_check();	
}

注册字符设备，绑定相关回调函数

static int ds18b20_open(struct inode *inode, struct file *filp)
{
	return 0;
}

static ssize_t ds18b20_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 
{
    int ret;
    ret = copy_to_user(buf, &ds18b20.data[0], 2);
	if(ret)
        return -ENOMEM;
	return ret;
}

static struct file_operations ds18b20_fops = {
	.owner	= THIS_MODULE,
	.open = ds18b20_open,
	.read	= ds18b20_read,
};

static void ds18b20_work_callback(struct work_struct *work)
{
    ds18b20_start();                            /*  ds1820 start convert */
    ds18b20_reset();
    ds18b20_check();
    ds18b20_write_byte(0xcc);                   /*  skip rom */
    ds18b20_write_byte(0xbe);                   /*  convert */
    ds18b20.data[0] = ds18b20_read_byte();      /*  LSB */
    ds18b20.data[1] = ds18b20_read_byte();      /*  MSB */
}

static void ds18b20_timer_callback(struct timer_list *arg)
{
    schedule_work(&ds18b20.work);	
    mod_timer(&ds18b20.timer, jiffies + (1000 * HZ/1000));	
}

static int ds18b20_module_init(void)
{
    int ret = 0;
    ds18b20.gpio = DS18B20_GPIO;
    if (!gpio_is_valid(ds18b20.gpio)) {
        return -EINVAL;
    }

    ret = gpio_request(ds18b20.gpio, "DS18B20-GPIO");
    if (ret) {
        printk(KERN_ERR "ds18b20 : Failed to request gpio\n");
        return ret;
	}

    ds18b20_init();

    if (ds18b20.major) {		
		ds18b20.dev_id = MKDEV(ds18b20.major, 0);
		ret = register_chrdev_region(ds18b20.dev_id, DS18B20_DEV_NUM, DS18B20_DEV);
		if(ret < 0) {
			pr_err("cannot register %s char driver [ret=%d]\n", DS18B20_DEV, DS18B20_DEV_NUM);
			goto free_gpio;
		}
	} 
    else {					
		ret = alloc_chrdev_region(&ds18b20.dev_id, 0, DS18B20_DEV_NUM, DS18B20_DEV);
		if(ret < 0) {
			pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", DS18B20_DEV, ret);
			goto free_gpio;
		}
		ds18b20.major = MAJOR(ds18b20.dev_id);	
		ds18b20.minor = MINOR(ds18b20.dev_id);	
	}
	
	ds18b20.cdev.owner = THIS_MODULE;
	cdev_init(&ds18b20.cdev, &ds18b20_fops);
	cdev_add(&ds18b20.cdev, ds18b20.dev_id, DS18B20_DEV_NUM);
	if(ret < 0)
		goto del_unregister;
		
	ds18b20.class = class_create(THIS_MODULE, DS18B20_DEV);
	if (IS_ERR(ds18b20.class)) {
		goto del_cdev;
	}

	ds18b20.device = device_create(ds18b20.class, NULL, ds18b20.dev_id, NULL, DS18B20_DEV);
	if (IS_ERR(ds18b20.device)) {
		goto destroy_class;
	}

	timer_setup(&ds18b20.timer, ds18b20_timer_callback, 0);
    ds18b20.timer.expires=jiffies + msecs_to_jiffies(1000);
    add_timer(&ds18b20.timer);
	INIT_WORK(&ds18b20.work, ds18b20_work_callback);

    return 0;

destroy_class:
	class_destroy(ds18b20.class);
del_cdev:
	cdev_del(&ds18b20.cdev);
del_unregister:
	unregister_chrdev_region(ds18b20.dev_id, DS18B20_DEV_NUM);
free_gpio:
	gpio_free(ds18b20.gpio);
	return -EIO;
}

整合代码

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/errno.h>

#define DS18B20_DEV_NUM			1		  
#define DS18B20_DEV		        "ds18b20"	
#define DS18B20_GPIO            48	
#define DS18B20_DQ_OUT(x)       gpio_direction_output(ds18b20.gpio, x)
#define DS18B20_DQ_IN           ds18b20_get_io()

struct ds18b20_dev {
    dev_t dev_id;		
	struct cdev cdev;	
	struct class *class;	
	struct device *device;	
	int major;			
	int minor;	
    int gpio;				
    unsigned char data[2]; 
	struct timer_list timer;	
    struct work_struct work;
};

struct ds18b20_dev ds18b20;

static int ds18b20_get_io(void)
{
    gpio_direction_input(ds18b20.gpio);
    return gpio_get_value(ds18b20.gpio); 
}

static void ds18b20_reset(void)
{
    DS18B20_DQ_OUT(0);  /* 拉低DQ,复位 */
    udelay(750);      /* 拉低750us */
    DS18B20_DQ_OUT(1);  /* DQ=1, 释放复位 */
    udelay(15);       /* 延迟15US */
}

uint8_t ds18b20_check(void)
{
    uint8_t retry = 0;
    uint8_t rval = 0;

    while (DS18B20_DQ_IN && retry < 200)    /* 等待DQ变低, 等待200us */
    {
        retry++;
        udelay(1);
    }

    if (retry >= 200)
    {
        rval = 1;
    }
    else
    {
        retry = 0;

        while (!DS18B20_DQ_IN && retry < 240)   /* 等待DQ变高, 等待240us */
        {
            retry++;
            udelay(1);
        }

        if (retry >= 240) rval = 1;
    }

    return rval;
}

static uint8_t ds18b20_read_bit(void)
{
    uint8_t data = 0;
    DS18B20_DQ_OUT(0);
    udelay(2);
    DS18B20_DQ_OUT(1);
    udelay(12);

    if (DS18B20_DQ_IN)
    {
        data = 1;
    }

    udelay(50);
    return data;
}

static uint8_t ds18b20_read_byte(void)
{
    uint8_t i, b, data = 0;

    for (i = 0; i < 8; i++)
    {
        b = ds18b20_read_bit(); /* DS18B20先输出低位数据 ,高位数据后输出 */

        data |= b << i;         /* 填充data的每一位 */
    }

    return data;
}

static void ds18b20_write_byte(uint8_t data)
{
    uint8_t j;
    for (j = 1; j <= 8; j++)
    {
        if (data & 0x01)
        {
            DS18B20_DQ_OUT(0);  /*  Write 1 */
            udelay(2);
            DS18B20_DQ_OUT(1);
            udelay(60);
        }
        else
        {
            DS18B20_DQ_OUT(0);  /*  Write 0 */
            udelay(60);
            DS18B20_DQ_OUT(1);
            udelay(2);
        }

        data >>= 1;             /* 右移,获取高一位数据 */
    }
}

static void ds18b20_start(void)
{
    ds18b20_reset();
    ds18b20_check();
    ds18b20_write_byte(0xcc);   /*  skip rom */
    ds18b20_write_byte(0x44);   /*  convert */
}

static int ds18b20_init(void)
{
    gpio_direction_output(ds18b20.gpio, 0);
    ds18b20_reset();
    return ds18b20_check();	
}
 
static int ds18b20_open(struct inode *inode, struct file *filp)
{
	return 0;
}

static ssize_t ds18b20_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 
{
    int ret;
    ret = copy_to_user(buf, &ds18b20.data[0], 2);
	if(ret)
        return -ENOMEM;
	return ret;
}

static struct file_operations ds18b20_fops = {
	.owner	= THIS_MODULE,
	.open = ds18b20_open,
	.read	= ds18b20_read,
};

static void ds18b20_work_callback(struct work_struct *work)
{
    ds18b20_start();                            /*  ds1820 start convert */
    ds18b20_reset();
    ds18b20_check();
    ds18b20_write_byte(0xcc);                   /*  skip rom */
    ds18b20_write_byte(0xbe);                   /*  convert */
    ds18b20.data[0] = ds18b20_read_byte();      /*  LSB */
    ds18b20.data[1] = ds18b20_read_byte();      /*  MSB */
}

static void ds18b20_timer_callback(struct timer_list *arg)
{
    schedule_work(&ds18b20.work);	
    mod_timer(&ds18b20.timer, jiffies + (1000 * HZ/1000));	
}

static int ds18b20_module_init(void)
{
    int ret = 0;
    ds18b20.gpio = DS18B20_GPIO;
    if (!gpio_is_valid(ds18b20.gpio)) {
        return -EINVAL;
    }

    ret = gpio_request(ds18b20.gpio, "DS18B20-GPIO");
    if (ret) {
        printk(KERN_ERR "ds18b20 : Failed to request gpio\n");
        return ret;
	}

    ds18b20_init();

    if (ds18b20.major) {		
		ds18b20.dev_id = MKDEV(ds18b20.major, 0);
		ret = register_chrdev_region(ds18b20.dev_id, DS18B20_DEV_NUM, DS18B20_DEV);
		if(ret < 0) {
			pr_err("cannot register %s char driver [ret=%d]\n", DS18B20_DEV, DS18B20_DEV_NUM);
			goto free_gpio;
		}
	} 
    else {					
		ret = alloc_chrdev_region(&ds18b20.dev_id, 0, DS18B20_DEV_NUM, DS18B20_DEV);
		if(ret < 0) {
			pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", DS18B20_DEV, ret);
			goto free_gpio;
		}
		ds18b20.major = MAJOR(ds18b20.dev_id);	
		ds18b20.minor = MINOR(ds18b20.dev_id);	
	}
	
	ds18b20.cdev.owner = THIS_MODULE;
	cdev_init(&ds18b20.cdev, &ds18b20_fops);
	cdev_add(&ds18b20.cdev, ds18b20.dev_id, DS18B20_DEV_NUM);
	if(ret < 0)
		goto del_unregister;
		
	ds18b20.class = class_create(THIS_MODULE, DS18B20_DEV);
	if (IS_ERR(ds18b20.class)) {
		goto del_cdev;
	}

	ds18b20.device = device_create(ds18b20.class, NULL, ds18b20.dev_id, NULL, DS18B20_DEV);
	if (IS_ERR(ds18b20.device)) {
		goto destroy_class;
	}

	timer_setup(&ds18b20.timer, ds18b20_timer_callback, 0);
    ds18b20.timer.expires=jiffies + msecs_to_jiffies(1000);
    add_timer(&ds18b20.timer);
	INIT_WORK(&ds18b20.work, ds18b20_work_callback);

    return 0;

destroy_class:
	class_destroy(ds18b20.class);
del_cdev:
	cdev_del(&ds18b20.cdev);
del_unregister:
	unregister_chrdev_region(ds18b20.dev_id, DS18B20_DEV_NUM);
free_gpio:
	gpio_free(ds18b20.gpio);
	return -EIO;
}


static void ds18b20_module_exit(void)
{
	cdev_del(&ds18b20.cdev);
	unregister_chrdev_region(ds18b20.dev_id, DS18B20_DEV_NUM); 
	device_destroy(ds18b20.class, ds18b20.dev_id);
	class_destroy(ds18b20.class);
	del_timer(&ds18b20.timer);
    cancel_work_sync(&ds18b20.work);
    gpio_free(ds18b20.gpio); 
}

module_init(ds18b20_module_init);
module_exit(ds18b20_module_exit);
MODULE_LICENSE("GPL");

Makefile文件

obj-m += ds18b20.o 
KDIR:=/home/asensing/loongson/linux-4.19
ARCH=loongarch 
CROSS_COMPILE=loongarch64-linux-gnu-
PWD?=$(shell pwd) 
all:
	make -C $(KDIR) M=$(PWD) modules

构建脚本

export PATH=$PATH:/home/asensing/loongson/loongson-gnu-toolchain-8.3-x86_64-loongarch64-linux-gnu-rc1.3-1/bin
make -j8
loongarch64-linux-gnu-gcc test.c -o test
FILE=$PWD/$(basename $PWD).ko
scp $FILE test root@192.168.137.216:/home/root

测试用例

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

#define DEV_NAME "/dev/ds18b20"

int main()
{
    int fd, ret;
    unsigned char result[2];
    unsigned char TH, TL;
    short tmp = 0;
    float temperature;
    int flag = 0;

    fd = open(DEV_NAME, 0);

    if(fd < 0)
    {
        printf("open %s device failed\n", DEV_NAME);
        exit(1);
    }
    else
        printf("Open %s success!\n", DEV_NAME);

    while(1)
    {
        ret = read(fd, &result, sizeof(result)); 
		if(ret == 0) {	/* 读取到数据 */
			TL = result[0];
			TH = result[1];
    
			if(TH > 7) {	/* 负数处理 */
				TH = ~TH;
				TL = ~TL;
				flag = 1;	/* 标记为负数 */
			}
			tmp = TH;
			tmp <<= 8;
			tmp += TL;

			if(flag == 1) {
				temperature = (float)(tmp+1) * 0.0625; /* 计算负数的温度 */
				temperature = -temperature;
			}else {
				temperature = (float)tmp *0.0625;	/* 计算正数的温度 */
			}            

			if(temperature < 125 && temperature > -55) {	/* 温度范围 */
				printf("Environment Temperature Now : %0.2f℃\n", temperature);
			}
		}
		flag = 0;
		sleep(1);
    }
	close(fd);	/* 关闭文件 */
}

设备树版驱动

当然也可以使用设备树描述节点（对应的设备树IO为 gpa3 0 1），文件路径：arch/loongarch/boot/dts/loongson/loongson_2k0300.dtsi

ds18b20 {
    compatible = "loongson,ds18b20";
    ds18b20-gpio = <&gpa3 0 1>;
    status = "okay";
};

驱动代码部分需要改为platform_driver的方式进行匹配，其它逻辑跟上面的保持一致，这里不详细展开了

static const struct of_device_id of_math_table[] = {
	{ .compatible = "loongson,ds18b20" },
};

static struct platform_driver ds18b20_driver = {
	.driver = {
		.name			= "ds18b20",
		.of_match_table	= of_math_table,
	},
	.probe		= ds18b20_probe,
	.remove		= ds18b20_remove,
};

通过of函数获取GPIO节点

static int ds18b20_init_gpio(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    int ret;
    ds18b20.gpio = of_get_named_gpio(dev->of_node, "ds18b20-gpio", 0);
    if (!gpio_is_valid(ds18b20.gpio)) {
        return -EINVAL;
    }

    ret = devm_gpio_request(dev, ds18b20.gpio, "DS18B20 Gpio");
    if (ret) {
        return ret;
    }
    return 0;
}

实验效果

插入驱动后，使用测试用例实时读取环境温度值

在这里插入图片描述

广东太热，我要回非洲！

在这里插入图片描述

参考

以上驱动参考自RT-Thread的工程：rtt-psoc62/one-wire/ds18b20.c at main · hywing/rtt-psoc62 (github.com)

下里巴人hywing
关注
专栏目录
龙芯1B环境驱动问题安装文档
10-18
龙芯1B环境驱动问题安装文档 龙芯1B环境驱动问题安装文档是龙芯1B开发板的驱动程序安装指南，旨在帮助开发者解决驱动程序安装过程中可能出现的问题。本文档涵盖了驱动程序的安装、卸载、检测和配置等方面的知识点，...
龙芯2k0300的GPIO的驱动及使用
学无止境，止于至善
08-15 1183
龙芯2K0300的GPIO（General Purpose Input/Output，通用输入输出）使用涉及多个步骤，包括配置设备树、编写驱动程序以及在用户空间进行交互。下面通过一个具体的例子——LED灯的控制，来说明龙芯2K0300的GPIO如何使用。
龙芯2K0300开发笔记（新手向:到点灯和视频图像颜色识别处理）
L_Z_J_I的博客
07-15 2886
四天三夜电赛学龙芯2K0300的笔记以及新手教程
龙芯L2K0300开发板综合测试
hywing's blog
09-05 875
Linux环境下进行开发板测试
【驱动篇】龙芯LS2K0300之LED驱动
hywing's blog
06-22 838
Linux LED驱动及测试用例
龙芯LS2K0300久久派上手体验
hywing's blog
06-19 2871
龙芯SOC初体验
【驱动篇】龙芯LS2K0300之驱动示例
hywing's blog
06-21 754
最小Linux驱动
基于龙芯 2K1000 的嵌入式 Linux 系统移植和驱动程序设计（二）
YEYUANGEN的专栏
02-21 1553
环境，因此需要汇编代码来完成一些处理器和内存等设备的初始化，完成准备工作。进程的软件，因此进程调度属于内核中非常重要的功能。但是根文件系统负责配置工作，不同的处理器配置方法和具体内容不同，因此根文件系统和内核分离，可以让嵌入。程调度会通过合理切换多进程让宏观上多进程并行，无论何时都有进程运行，使。中它与内核一般是分开的，这是由于内核负责一些进程调度等操作系统的基本工。通过使用可执行脚本，将编译根文件系统步骤放在一个脚本文件中，减少操作。配置串口的波特率，由于本课题中不使用串口而是直接外接屏幕来显示，因此。
龙芯LS2K嵌入式模块：串口通信与驱动开发
"该资源主要涉及一款基于国产Loongson LS2K处理器的嵌入式解决方案，产品特点是体积小巧、高集成度、稳定性强。产品采用COME接口，尺寸为84mm x 55mm x 10mm，内置4片512MB DDR3内存（总计2GB），两片非SPI接口的...
国产龙芯LS2K1000嵌入式模块：COM接口，串口通信驱动开发
"产品特点-epics下串口通信驱动程序的开发" 在本文中，我们将深入探讨基于龙芯LS2K1000处理器的工业级模块，这是一款完全国产化的处理器，旨在提供高效能、高可靠性的嵌入式解决方案。龙芯LS2K1000是一款64位双核...
龙芯2K1000 Local IO与FPGA外扩总线设计思想
05-22
《龙芯2K1000 Local IO与FPGA外扩总线设计解析》 本文主要探讨了基于龙芯2K1000处理器的Local IO接口如何与FPGA进行有效的外扩总线设计，旨在为初学者提供一种经典的设计方法。设计中，通过Local IO接口，可以扩展...
龙芯LS2K0500开发板：全国产高性能硬件规格详解
"迅为iTOP-LS2K0500开发板是一款基于龙芯LS2K0500处理器的开发平台，该处理器采用了龙芯自主指令系统（LoongArch）架构，旨在为嵌入式系统开发提供国产化的解决方案。开发板集成了64位LA264处理器核、32位DDR3内存...
【驱动篇】龙芯LS2K0300之spi设备驱动
hywing's blog
07-11 694
Linux GC9A01 SPI设备驱动
MiniGui业务开发基础培训-htk
最新发布
11-11
MiniGui业务开发基础培训-htk
com.harmonyos.exception.DiskReadWriteException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
网络分析-Wireshark数据包筛选技巧详解及应用实例
11-11
内容概要：本文档详细介绍了Wireshark软件中各种数据包筛选规则，主要包括协议、IP地址、端口号、包长以及MAC地址等多个维度的具体筛选方法。同时提供了大量实用案例供读者学习，涵盖HTTP协议相关命令和逻辑条件的综合使用方式。 适合人群：对网络安全或数据分析有一定兴趣的研究者，熟悉基本网络概念和技术的专业人士。 使用场景及目标：适用于需要快速准确捕获特定类型网络流量的情况；如网络安全检测、性能优化分析、教学演示等多种实际应用场景。 阅读建议：本资料侧重于实操技能提升，在学习时最好配合实际操作练习效果更佳。注意掌握不同类型条件组合的高级用法，增强问题解决能力。
com.harmonyos.exception.BatteryOverheatException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
com.harmonyos.exception.ServiceUnavailableException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

下里巴人hywing

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值