10.11嵌入式作业（ioctl控制设备驱动）

已于 2022-10-11 20:46:40 修改
阅读量169 收藏
点赞数 1
文章标签： 驱动开发 嵌入式硬件 stm32 单片机 arm
于 2022-10-11 20:45:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55853947/article/details/127271333
版权

文章目录

作业内容

编写代码，实现通过ioctl函数控制开发板的LED灯、蜂鸣器、风扇的驱动

代码部分

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

typedef struct
{
    volatile unsigned int MODER;
    volatile unsigned int OTYPER;
    volatile unsigned int OSPEEDR;
    volatile unsigned int PUPDR;
    volatile unsigned int IDR;
    volatile unsigned int ODR;
    volatile unsigned int BSRR;
    volatile unsigned int LCKR;
    volatile unsigned int AFRL;
} gpio_t;

#define PHY_LED1_ADDR 0x50006000
#define PHY_LED2_ADDR 0x50007000
#define PHY_LED3_ADDR 0x50006000
#define PHY_FAN_ADDR 0x50006000
#define PHY_BUZZER_ADDR 0x50003000
#define PHY_RCC_ADDR 0x50000A28

#define LED_ON _IOW('a', 1, int)
#define LED_OFF _IOW('a', 0, int)

#define FAN_ON _IO('a', 1)
#define FAN_OFF _IO('a', 0)

#define BUZZER_ON _IO('a', 1)
#define BUZZER_OFF _IO('a', 0)

#endif

myled.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include "head.h"
#define CNAME "mycdev"

int major;           //定义变量接收主设备号
char kbuf[128] = {}; //定义数组用于存放和用户之间拷贝的数据

gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;

unsigned int *vir_rcc;
struct class *cls; //句柄
struct device *dev;

//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
// read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    // size参数是用户期待读到的字节长度
    int ret;
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
    return size;
}
// write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_from_user(kbuf, ubuf, size);
    if (ret)
    {
        printk("数据从用户向内核拷贝失败\n");
        return -EIO;
    }
    return size;
}

long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int ret, which;
    ret = copy_from_user(&which, (void *)arg, sizeof(int));
    if (ret)
    {
        printk("数据从用户向内核拷贝失败\n");
        return -EIO;
    }
    switch (cmd)
    {
    case LED_ON:
        if (which == 1)
            vir_led1->ODR |= (1 << 10);
        else if (which == 2)
            vir_led2->ODR |= (1 << 10);
        else if (which == 3)
            vir_led3->ODR |= (1 << 8);
        break;
    case LED_OFF:
        if (which == 1)
            vir_led1->ODR &= ~(1 << 10);
        else if (which == 2)
            vir_led2->ODR &= ~(1 << 10);
        else if (which == 3)
            vir_led3->ODR &= ~(1 << 8);
        break;
    default:
        printk("功能码错误\n");
        break;
    }
    return 0;
}
// close()
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
//操作方法结构体的初始化
struct file_operations fops =
    {
        .open = mycdev_open,
        .read = mycdev_read,
        .write = mycdev_write,
        .unlocked_ioctl = ioctl,
        .release = mycdev_close,
};

int all_led_init(void)
{
    //进行物理地址的映射
    vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    if (vir_led1 == NULL)
    {
        printk("vir_led1 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led1 映射成功\n");

    vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    if (vir_led2 == NULL)
    {
        printk("vir_led2 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led2 映射成功\n");

    vir_led3 = ioremap(PHY_LED3_ADDR, sizeof(gpio_t));
    if (vir_led3 == NULL)
    {
        printk("vir_led3 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led3 映射成功\n");

    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");

    //寄存器的初始化
    // led1
    vir_led1->MODER &= ~(3 << 20);
    vir_led1->MODER |= (1 << 20);
    vir_led1->ODR &= ~(1 << 10);

    // led2
    vir_led2->MODER &= ~(3 << 20);
    vir_led2->MODER |= (1 << 20);
    vir_led2->ODR &= ~(1 << 10);

    // led3
    vir_led3->MODER &= ~(3 << 16);
    vir_led3->MODER |= (1 << 16);
    vir_led3->ODR &= ~(1 << 8);

    // rcc
    (*vir_rcc) |= (3 << 4);
    return 0;
}

//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{
    //动态注册字符设备驱动
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);

    //向上提交节点目录
    cls = class_create(THIS_MODULE, "LED");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
    printk("向上提交目录成功\n");

    //创建设备节点
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "myled");
    if (IS_ERR(dev))
    {
        printk("创建节点失败\n");
        return PTR_ERR(dev);
    }
    printk("创建节点成功\n");

    //寄存器的初始化
    all_led_init();
    return 0;
}

//出口函数，卸载驱动的时候执行
static void __exit demo_exit(void)
{
    //销毁节点
    device_destroy(cls, MKDEV(major, 0));
    //销毁目录
    class_destroy(cls);

    //取消映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_led3);
    iounmap(vir_rcc);

    //注销字符设备驱动
    unregister_chrdev(major, CNAME);
}
module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

mybuzzer.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/ioctl.h>
#include "head.h"
#define CNAME "mybuzzer"

int major;           //定义变量接受主设备号
char kbuf[128] = {}; //定义数组用于存放和用户之间拷贝的数据

gpio_t *vir_buzzer;

unsigned int *vir_rcc;
struct class *cls; //句柄
struct device *dev;

//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
// read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    // size参数是用户期待读到的字节长度
    int ret;
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
    return size;
}
// write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_from_user(kbuf, ubuf, size);
    if (ret)
    {
        printk("数据从用户向内核拷贝失败\n");
        return -EIO;
    }
    return size;
}

long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case BUZZER_ON:
        vir_buzzer->ODR |= (1 << 6);
        break;
    case BUZZER_OFF:
        vir_buzzer->ODR &= ~(1 << 6);
        break;
    default:
        printk("功能码错误\n");
        break;
    }
    return 0;
}
// close()
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
//操作方法结构体的初始化
struct file_operations fops =
    {
        .open = mycdev_open,
        .read = mycdev_read,
        .write = mycdev_write,
        .unlocked_ioctl = ioctl,
        .release = mycdev_close,
};

int buzzer_init(void)
{
    //进行物理地址的映射
    vir_buzzer = ioremap(PHY_BUZZER_ADDR, sizeof(gpio_t));
    if (vir_buzzer == NULL)
    {
        printk("vir_buzzer 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_buzzer 映射成功\n");

    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");

    //寄存器的初始化
    vir_buzzer->MODER &= ~(3 << 12);
    vir_buzzer->MODER |= (1 << 12);
    vir_buzzer->ODR &= ~(1 << 6);

    (*vir_rcc) |= (1 << 1);

    return 0;
}

//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{
    //动态注册字符设备驱动
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0)
    {
        printk("蜂鸣器设备驱动注册失败\n");
        return major;
    }
    printk("蜂鸣器设备驱动注册成功major=%d\n", major);

    //向上提交节点目录
    cls = class_create(THIS_MODULE, "BUZZER");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
    printk("向上提交目录成功\n");

    //创建设备节点
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "mybuzzer");
    if (IS_ERR(dev))
    {
        printk("创建节点失败\n");
        return PTR_ERR(dev);
    }
    printk("创建节点成功\n");

    //寄存器的初始化
    buzzer_init();
    return 0;
}

//出口函数，卸载驱动的时候执行
static void __exit demo_exit(void)
{
    //销毁节点
    device_destroy(cls, MKDEV(major, 0));
    //销毁目录
    class_destroy(cls);

    //取消映射
    iounmap(vir_buzzer);
    iounmap(vir_rcc);

    //注销字符设备驱动
    unregister_chrdev(major, CNAME);
}

module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

myfan.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/ioctl.h>
#include "head.h"
#define CNAME "myfan"

int major;           //定义变量接受主设备号
char kbuf[128] = {}; //定义数组用于存放和用户之间拷贝的数据

gpio_t *vir_fan;

unsigned int *vir_rcc;
struct class *cls; //句柄
struct device *dev;

//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
// read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    // size参数是用户期待读到的字节长度
    int ret;
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
    return size;
}
// write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_from_user(kbuf, ubuf, size);
    if (ret)
    {
        printk("数据从用户向内核拷贝失败\n");
        return -EIO;
    }
    return size;
}

long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case FAN_ON:
        vir_fan->ODR |= (1 << 9);
        break;
    case FAN_OFF:
        vir_fan->ODR &= ~(1 << 9);
        break;
    default:
        printk("功能码错误\n");
        break;
    }
    return 0;
}
// close()
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
//操作方法结构体的初始化
struct file_operations fops =
    {
        .open = mycdev_open,
        .read = mycdev_read,
        .write = mycdev_write,
        .unlocked_ioctl = ioctl,
        .release = mycdev_close,
};

int fan_init(void)
{
    //进行物理地址的映射
    vir_fan = ioremap(PHY_FAN_ADDR, sizeof(gpio_t));
    if (vir_fan == NULL)
    {
        printk("vir_fan 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_fan 映射成功\n");

    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");

    //寄存器的初始化
    vir_fan->MODER &= ~(3 << 18);
    vir_fan->MODER |= (1 << 18);
    vir_fan->ODR &= ~(1 << 9);

    (*vir_rcc) |= (1 << 4);

    return 0;
}

//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{
    //动态注册字符设备驱动
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0)
    {
        printk("风扇设备驱动注册失败\n");
        return major;
    }
    printk("风扇设备驱动注册成功major=%d\n", major);

    //向上提交节点目录
    cls = class_create(THIS_MODULE, "FAN");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
    printk("向上提交目录成功\n");

    //创建设备节点
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "myfan");
    if (IS_ERR(dev))
    {
        printk("创建节点失败\n");
        return PTR_ERR(dev);
    }
    printk("创建节点成功\n");

    //寄存器的初始化
    fan_init();
    return 0;
}

//出口函数，卸载驱动的时候执行
static void __exit demo_exit(void)
{
    //销毁节点
    device_destroy(cls, MKDEV(major, 0));
    //销毁目录
    class_destroy(cls);

    //取消映射
    iounmap(vir_fan);
    iounmap(vir_rcc);

    //注销字符设备驱动
    unregister_chrdev(major, CNAME);
}

module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

test.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include "head.h"

int main(int argc, char const *argv[])
{
    char buf[128] = {};
    int fd1 = open("/dev/myled", O_RDWR);
    if (fd1 < 0)
    {
        printf("Open led device failed!\n");
        exit(-1);
    }
    printf("Open led device success!\n");

    int fd2 = open("/dev/mybuzzer", O_RDWR);
    if (fd2 < 0)
    {
        printf("Open buzzer device failed!\n");
        exit(-1);
    }
    printf("Open buzzer device success!\n");

    int fd3 = open("/dev/myfan", O_RDWR);
    if (fd3 < 0)
    {
        printf("Open fan device failed!\n");
        exit(-1);
    }
    printf("Open fan device success!\n");

    int which;
    while (1)
    {
        //在终端输入
        printf("请选择要控制的设备 1：LED灯 2：蜂鸣器 3：风扇\n");
        scanf("%d", &which);
        getchar();
        if (which == 1) // LED灯
        {
            printf("请输入控制选项 1：点亮 2：熄灭\n");
            fgets(buf, sizeof(buf), stdin);
            buf[strlen(buf) - 1] = 0;
            printf("请选择要开关的LED灯1/2/3：\n");
            scanf("%d", &which);
            getchar();
            if (buf[0] == '1')
                ioctl(fd1, LED_ON, &which);
            else
                ioctl(fd1, LED_OFF, &which);
        }
        else if (which == 2) //蜂鸣器
        {
            printf("请输入控制选项 1：开蜂鸣器 2：关蜂鸣器\n");
            bzero(buf, sizeof(buf));
            fgets(buf, sizeof(buf), stdin);
            buf[strlen(buf) - 1] = 0;
            if (buf[0] == '1')
                ioctl(fd2, BUZZER_ON);
            else
                ioctl(fd2, BUZZER_OFF);
        }
        else if (which == 3) //风扇
        {
            printf("请输入控制选项 1：打开风扇 2：关闭风扇\n");
            fgets(buf, sizeof(buf), stdin);
            buf[strlen(buf) - 1] = 0;
            if (buf[0] == '1')
                ioctl(fd3, FAN_ON);
            else
                ioctl(fd3, FAN_OFF);
        }
    }

    close(fd1);
    close(fd2);
    close(fd3);
    return 0;
}
ᗡ
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
触摸按键控制LED灯实验
qq_45565330的博客
11-15 494
触摸按键控制LED灯实验
macOS 10.11 - 10.15 RTL 芯片网卡驱动
02-09
支持到最新macOS 10.15 RTL芯片无线网卡基本都支持最新版本，安装后重新启动生效。测试USB网卡可以正常使用，网卡型号为水星MW150US 芯片型号RTL8188EU
2022-10-11使用ioctl函数实现LED灯，蜂鸣器，风扇的驱动工作
m0_58344947的博客
10-11 241
首先是led灯的头文件部分。然后是蜂鸣器的驱动部分代码。然后是蜂鸣器的头文件部分。后面是风扇的头文件部分。最后是应用层的实现代码（三个器件一起初始化使用）然后是 myled.c的驱动文件。
嵌入式Linux驱动开发初级-字符设备驱动基IO模型
found_1的博客
03-08 125
嵌入式Linux驱动开发初级-字符设备驱动基IO模型
#ARM开发# 点亮LED和操作蜂鸣器
zer1123的博客
07-06 3548
实例：Mini2451_Led_s  （文件名） 设备：ARM实验板 PC机 编译环境：KEIL4   MiniTools 实验前准备：   实验板接通电源（不需要打开），连接电脑。打开MiniTools，按住实验板最边上的按钮同时开机，如显示没有连接成功，查看驱动是否安装完全，已经安装驱动的就可以直接显示connected。此时可以从Minitools中把 . bin
【STM32】控制LED灯和蜂鸣器的按键实验
热门推荐
weixin_63726869的博客
05-18 1万+
介绍了如何通过STM32开发板的按键控制LED灯和蜂鸣器的状态。
mac10.11 alc887 驱动
06-12
在Mac系统中，AppleHDA.kext文件是负责音频硬件驱动的关键组件，它允许系统识别和控制各种音频设备，包括ALC887这样的编解码器。 在安装和使用ALC887驱动时，用户需要注意以下几点： 1. **兼容性检查**：确保你的...
声卡驱动10.13.6 10.12 10.11
10-19
标题 "声卡驱动10.13.6 10.12 10.11" 提供的信息是关于适用于Apple操作系统特定版本的声卡驱动程序，这主要是针对Mac OS X系统，其中10.13.6、10.12和10.11分别代表High Sierra、Sierra和El Capitan这三个不同的 ...
day03
mailong
06-16 166
回顾： 1.linux设备驱动开发相关   1.1.设备驱动两大核心       操作硬件       提供接口   1.2.linux设备驱动分类           字符设备驱动           块设备驱动           网络设备驱动   1.3.linux系统理念       一切皆文件       字符设备文件       块设备文
arm下蜂鸣器测试代码
xdshengk的博客
06-24 1636
首先还是看内核蜂鸣器的实现，如下图，这个和led一样，都是比较简单的字符驱动，代码如下： #include #include #include void main() { int fd; int freq = 0; fd = open("/dev/beep",O_RDWR); while(1) { //ioctl(fd,1,1); ioctl(fd,1,freq); sle
arm控制蜂鸣器的蜂鸣程序
12-03
这个程序时ARM7TDMIPLC2106的芯片，控制蜂鸣器的蜂鸣实验，该蜂鸣器时利用低电平出发方式进行的。
ARM GPIO 实验 -- 蜂鸣器
01-14
ARM GPIO 实验 -- 蜂鸣器 基于 mini2440 开发的裸机实验代码，使用 jtag 下载在到 内部 SDRAM 中运行。
ARM控制蜂鸣器
06-03
ARM控制蜂鸣器；；控制蜂鸣器的好代码哦。。值得下载。。
编写LED混杂设备驱动：静态映射，如何用Linux内核里的gpio_request(),gpio_set_value()等函数，ioctl函数
欧阳海宾
08-16 5495
如何用Linux内核里的gpio_request(),gpio_set_value()等函数编写LED驱动          步骤一：打开Linux内核源代码里的Documentation文件夹下的gpio.txt文档          文档里介绍了要用到的头文件和gpio函数介绍，用到的头文件是 #include 步骤二：打开Linux sourceindight工程搜索gpio.
Driver：LED灯操作、内核空间和用户空间的数据交互、ioctl函数、设备文件安装与销毁
Hello, New World!
03-04 1307
1、LED灯操作 用户空间执行open时，led1亮；执行close时，led1灭。 电路原理图：     led1 ---> GPIOC12 如何控制：     cpu datasheet 特殊功能寄存器 在linux下操作GPIO管脚有两种方式：     1)像裸板开发一样通过'指针 + 位操作'来完成特殊功能寄存器的设置。         问题在于：/* 要将特殊功能寄存
第46讲 控制蜂鸣器
jiazihuangtian的博客
10-15 544
LED子系统已经把硬件的操作接口导出到用户空间了，但是GPIO子系统并没有帮我们把控制蜂鸣器的GPIO接口导出到用户空间，我们需要手动去导出。direction主要用来控制GPIO19的输入输出模式，当设置in时，GPIO19出于输入模式，设置为out时成为输出模式。value表示，在输出模式时，将其置1表示此芯片输出高电平，value为0时，芯片输出底电平。可以看到开发板的系统中，GPIO文件夹下并没有19的操作接口，但是有export。最后没有gcc的命令，好像是自动编译的吧，，
第十七节 控制蜂鸣器（GPIO 子系统）
picassocao的博客
02-07 1123
控制蜂鸣器（GPIO 子系统）
I.MX6ULL ARM驱动开发--- pinctrl 和 gpio 子系统的蜂鸣器驱动
qq_41455322的博客
08-23 691
I.MX6ULL ARM驱动开发--- pinctrl 和 gpio 子系统的蜂鸣器驱动
10.11.33.75
最新发布
04-20
10.11.33.75是一个IP地址，它是一个用于在计算机网络中标识设备的唯一地址。IP地址分为IPv4和IPv6两种类型，10.11.33.75是IPv4地址的一种。IPv4地址由四个由点分隔的十进制数表示，每个数的取值范围是0到255。 关于10.11.33.75的具体信息，我无法提供，因为我没有访问互联网的能力。如果您想了解更多关于该IP地址的信息，您可以尝试使用一些网络工具或者查询相关的网络数据库来获取更多详细信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值