code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
package com.jcm.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.domain.SysDictType;
import org.apache.ibatis.annotations.Param;
import java.util.ArrayList;
import java.util.List;
/**
* <p>
* 字典配置项 Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2024-10-31
*/
public interface SysDictTypeMapper extends BaseMapper<SysDictType> {
ArrayList<SysDictType> selectDictTypeAndExtraAllList();
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysDictTypeMapper.java
|
Java
|
unknown
| 461
|
package com.jcm.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.api.domain.SysLogininfor;
import org.apache.ibatis.annotations.Delete;
/**
* logininforMapper接口
*
* @author lvshihao
* @date 2025-01-11
*/
public interface SysLogininforMapper extends BaseMapper<SysLogininfor>
{
@Delete("TRUNCATE TABLE sys_logininfor")
void clearLogininfor();
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysLogininforMapper.java
|
Java
|
unknown
| 410
|
package com.jcm.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.domain.SysMenu;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2024-04-21
*/
public interface SysMenuMapper extends BaseMapper<SysMenu> {
/**
* 根据用户ID查询所拥有的权限列表
* @param id 用户ID
* @return 用户所拥有的权限列表
*/
List<String> selectMenuPermsByUserId(Long id);
/**
* 查询全部的菜单树
* @param visible 是否查询隐藏菜单数据 路由需要，菜单不需要
* @return 全部的菜单树
*/
List<SysMenu> selectMenuTreeAll(@Param("visible") Boolean visible);
/**
* 根据用户ID查询所拥有的菜单树
* @param userId 用户ID
* @param visible 是否查询隐藏菜单数据 路由需要，菜单不需要
* @return 用户拥有的菜单树
*/
List<SysMenu> selectMenuTreeByUserId(@Param("userId") Long userId,@Param("visible") Boolean visible);
/**
* 获取新增菜单最后的sort值
* @param parentId 父菜单id
* @return 用户拥有的菜单树
*/
Integer selectMenuChildLastSort(Long parentId);
/**
* 修改菜单及所有子菜单的状态/显示状态
* @param menuList 当前菜单以及所有子菜单的列表
* @param status 修改的状态
* @param visible 修改的显示状态
* @return 用户拥有的菜单树
*/
int updateBatchById(@Param("menuList") List<SysMenu> menuList,@Param("status") Integer status,@Param("visible") Boolean visible);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysMenuMapper.java
|
Java
|
unknown
| 1,684
|
package com.jcm.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.api.domain.SysOperLog;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 操作日志记录 Mapper 接口
* </p>
*
* @author 吕世昊
*/
public interface SysOperLogMapper extends BaseMapper<SysOperLog> {
/**
* 定义方法用于截断（清空）sys_oper_log表
* @return
*/
@Delete("TRUNCATE TABLE sys_oper_log")
void clearOperLog();
List<String> nameOptionSelect();
List<String> titleOptionSelect();
List<String> businessNameOptionSelectByTitle(String title);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysOperLogMapper.java
|
Java
|
unknown
| 700
|
package com.jcm.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.domain.SysRole;
import java.util.List;
/**
* <p>
* Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2024-04-01
*/
public interface SysRoleMapper extends BaseMapper<SysRole> {
/**
* 根据用户ID查询角色
*
* @param userId 用户ID
* @return 角色列表
*/
List<SysRole> selectRolePermissionByUserId(Long userId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysRoleMapper.java
|
Java
|
unknown
| 479
|
package com.jcm.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.domain.SysRoleMenu;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 用户和角色关联关系表 Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2024-04-20
*/
public interface SysRoleMenuMapper extends BaseMapper<SysRoleMenu> {
/**
* 批量新增角色菜单信息
*
* @param roleMenuList 用户角色列表
* @return 结果
*/
int batchRoleMenu(List<SysRoleMenu> roleMenuList);
/**
* 根据角色ID获取菜单ID列表
* @param roleId 用户ID
* @return
*/
List<Integer> queryMenuIdsByRoleId(Integer roleId);
/**
* 通过用户ID删除角色和菜单的关联
*
* @param roleId 用户ID
* @return 结果
*/
int deleteRoleMenuByRoleId(Long roleId);
int deleteByRoleIds(@Param("roleIds") List<Long> roleIds);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysRoleMenuMapper.java
|
Java
|
unknown
| 968
|
package com.jcm.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.api.domain.SysUser;
/**
* <p>
* 用户表 Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2024-04-01
*/
public interface SysUserMapper extends BaseMapper<SysUser> {
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysUserMapper.java
|
Java
|
unknown
| 291
|
package com.jcm.system.mapper;
import com.jcm.system.domain.SysUserRole;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.List;
/**
* <p>
* 用户和角色关联关系表 Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2024-04-20
*/
public interface SysUserRoleMapper extends BaseMapper<SysUserRole> {
/**
* 批量新增用户角色信息
*
* @param userRoleList 用户角色列表
* @return 结果
*/
int batchUserRole(List<SysUserRole> userRoleList);
/**
* 根据用户ID获取角色ID列表
* @param userId 用户ID
* @return
*/
List<Integer> selectAllocatedList(Long userId);
/**
* 通过用户ID删除用户和角色关联
*
* @param userId 用户ID
* @return 结果
*/
int deleteUserRoleByUserId(Long userId);
/**
* 通过角色ID查询角色使用数量
*
* @param roleId 角色ID
* @return 结果
*/
int countUserRoleByRoleId(Long roleId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysUserRoleMapper.java
|
Java
|
unknown
| 1,019
|
package com.jcm.system.mapper;
import com.jcm.system.domain.SysUserSetting;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 用户前端样式设置表 Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2024-12-18
*/
public interface SysUserSettingMapper extends BaseMapper<SysUserSetting> {
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysUserSettingMapper.java
|
Java
|
unknown
| 325
|
package com.jcm.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.domain.SysUserTask;
import java.util.List;
/**
* taskMapper接口
*
* @author lvshihao
* @date 2025-01-13
*/
public interface SysUserTaskMapper extends BaseMapper<SysUserTask>
{
List<SysUserTask> selectList(SysUserTask sysUserTask);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysUserTaskMapper.java
|
Java
|
unknown
| 359
|
package com.jcm.system.mapper;
import java.util.List;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.domain.TxVip;
/**
* vipMapper接口
*
* @author lvshihao
* @date 2025-01-11
*/
public interface TxVipMapper extends BaseMapper<TxVip>
{
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/TxVipMapper.java
|
Java
|
unknown
| 280
|
package com.jcm.system.service;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jcm.system.domain.SysDictData;
import java.util.List;
/**
* <p>
* 字典配置值 服务类
* </p>
*
* @author 吕世昊
*/
public interface ISysDictDataService extends IService<SysDictData> {
int insertDictData(SysDictData sysDictData);
List<SysDictData> selectDictDataList(SysDictData dictType);
int deleteDictData(List<Long> dictDataIds);
List<JSONObject> getInfoList(List<String> names);
List<JSONObject> getInfo(String name);
int updateDictData(SysDictData sysDictData);
void refreshDictDataCache();
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysDictDataService.java
|
Java
|
unknown
| 696
|
package com.jcm.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jcm.system.domain.SysDictType;
import java.util.List;
/**
* <p>
* 字典配置项 服务类
* </p>
*
* @author 吕世昊
*/
public interface ISysDictTypeService extends IService<SysDictType> {
/**
* 根据条件分页查询字典配置项数据
* @param dictType 字典项信息
* @return 字典项数据集合信息
*/
List<SysDictType> selectDictTypeList(SysDictType dictType);
/**
* 新增保存字典项信息
* @param dictType 字典项信息
* @return 结果
*/
int insertDictType(SysDictType dictType);
List<SysDictType> selectDictTypeAndExtraAllList();
int deleteDictType(List<Long> dictTypeIds);
int updateDictType(SysDictType sysDictType);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysDictTypeService.java
|
Java
|
unknown
| 841
|
package com.jcm.system.service;
import com.jcm.system.api.domain.SysLogininfor;
import java.util.List;
/**
* logininforService接口
*
* @author lvshihao
* @date 2025-01-11
*/
public interface ISysLogininforService
{
/**
* 查询系统访问记录列表
*
* @param sysLogininfor 系统访问记录
* @return 系统访问记录集合
*/
public List<SysLogininfor> selectSysLogininforList(SysLogininfor sysLogininfor);
/**
* 新增系统访问记录
*
* @param sysLogininfor 系统访问记录
* @return 结果
*/
public int insertSysLogininfor(SysLogininfor sysLogininfor);
/**
* 批量删除系统访问记录
*
* @param infoIds 需要删除的系统访问记录主键集合
* @return 结果
*/
public int deleteSysLogininforByInfoIds(Long[] infoIds);
/**
* 删除系统访问记录信息
*
* @param infoId 系统访问记录主键
* @return 结果
*/
public int deleteSysLogininforByInfoId(Long infoId);
int clearLogininfor();
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysLogininforService.java
|
Java
|
unknown
| 1,086
|
package com.jcm.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jcm.system.api.domain.SysUser;
import com.jcm.system.domain.SysMenu;
import com.jcm.system.domain.vo.RouterVo;
import java.util.List;
import java.util.Set;
/**
* <p>
* 服务类
* </p>
*
* @author 吕世昊
*/
public interface ISysMenuService extends IService<SysMenu> {
/**
* 获取菜单数据权限
*
* @param sysUser 用户
* @return 菜单权限信息
*/
Set<String> getMenuPermission(SysUser sysUser);
/**
* 根据用户ID获取菜单树
*
* @param userId 用户ID
* @return 菜单树信息
*/
List<SysMenu> selectMenuTreeByUserId(Long userId);
/**
* 将菜单树构建为路由结构
* @param menus 菜单树
* @param parentPath 父级菜单路径
* @return 路由树
*/
List<RouterVo> buildMenus(List<SysMenu> menus, String parentPath);
/**
* 获取全部菜单列表
* @param sysMenu
* @return 菜单权限信息
*/
List<SysMenu> selectMenuAllTree(SysMenu sysMenu);
/**
* 新增菜单
* @param sysMenu
* @return
*/
int insertMenu(SysMenu sysMenu);
/**
* 根据ID删除菜单
* @param menuId
* @return
*/
int deleteMenu(Long menuId);
/**
* 根据菜单信息
* @param menu
* @return
*/
int updateMenu(SysMenu menu);
/**
* 获取新增菜单最后的sort值
* @param parentId 父菜单id
* @return
*/
Integer getMenuChildLastSort(Long parentId);
/**
* 获取首页动态图标名称
* @return
*/
String getHomeMenuIcon();
int changeStatusWithChildStatus(SysMenu menu);
List<SysMenu> selectRouterTreeByUserId(Long userId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysMenuService.java
|
Java
|
unknown
| 1,826
|
package com.jcm.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jcm.system.api.domain.SysOperLog;
import java.util.List;
/**
* <p>
* 操作日志记录 服务类
* </p>
*
* @author 吕世昊
*/
public interface ISysOperLogService extends IService<SysOperLog> {
/**
* 新增操作日志
*
* @param operLog 操作日志对象
* @return 结果
*/
int insertOperlog(SysOperLog operLog);
/**
* 查找操作日志集合
*
* @sysOperLog 查询条件
* @return 结果
*/
List<SysOperLog> selectOperLogList(SysOperLog sysOperLog);
/**
* 删除操作日志
*
* @operIds 操作日志主键集合
* @return 结果
*/
int deleteOperLog(List<Long> operIds);
/**
* 清空操作日志
*
* @return 结果
*/
int clearOperLog();
/**
* 获取操作日志操作人员可选项
*
* @return 操作人员可选项集合
*/
List<String> nameOptionSelect();
/**
* 获取操作日志操模块标题可选项
*
* @return 模块标题可选项集合
*/
List<String> titleOptionSelect();
/**
* 获取操作日志操业务名称可选项
*
* @return 业务名称可选项集合
*/
List<String> businessNameOptionSelectByTitle(String title);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysOperLogService.java
|
Java
|
unknown
| 1,380
|
package com.jcm.system.service;
import java.util.List;
/**
* <p>
* 角色和菜单关联关系表 服务类
* </p>
*
* @author 吕世昊
*/
public interface ISysRoleMenuService {
/**
* 查询已分配角色菜单列表
* 根据角色ID获取菜单ID列表
* @param roleId 用户ID
* @return
*/
public List<Integer> queryMenuIdsByRoleId(Integer roleId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysRoleMenuService.java
|
Java
|
unknown
| 399
|
package com.jcm.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jcm.system.api.domain.SysUser;
import com.jcm.system.domain.SysRole;
import java.util.List;
import java.util.Set;
/**
* <p>
* 服务类
* </p>
*
* @author 吕世昊
*/
public interface ISysRoleService extends IService<SysRole> {
/**
* 根据用户ID查询角色权限
* @param userId 用户ID
* @return 权限列表
*/
List<SysRole> selectRolePermissionByUserId(Long userId);
/**
* 获取角色数据权限
* @param sysUser 用户
* @return 角色权限信息
*/
Set<String> getRolePermission(SysUser sysUser);
/**
* 校验角色名称是否唯一
* @param role 角色信息
* @return 结果
*/
boolean checkRoleNameUnique(SysRole role);
/**
* 校验角色名称是否唯一
* @param role 角色信息
* @return 结果
*/
boolean checkRoleKeyUnique(SysRole role);
/**
* 根据条件分页查询角色数据
* @param role 角色信息
* @return 角色数据集合信息
*/
List<SysRole> selectRoleList(SysRole role);
/**
* 通过角色ID查询角色
* @param roleId 角色ID
* @return 角色对象信息
*/
SysRole selectRoleById(Long roleId);
/**
* 新增保存角色信息
* @param role 角色信息
* @return 结果
*/
int insertRole(SysRole role);
/**
* 校验角色是否允许操作
* @param role 角色信息
*/
void checkRoleAllowed(SysRole role);
/**
* 修改角色状态
* @param role 角色信息
* @return 结果
*/
int updateRoleStatus(SysRole role);
/**
* 修改角色信息
* @param role 角色信息
* @return 结果
*/
int updateRole(SysRole role);
/**
* 删除角色信息
* @param roleIds 角色Id集合
* @return 结果
*/
int deleteRole(List<Long> roleIds);
/**
* 查询所有启用的角色
*
* @return 角色列表
*/
List<SysRole> selectRoleAll();
/**
* 批量选择菜单对角色授权
* @param roleId 角色ID
* @param menusId 菜单ID集合
* @return
*/
int insertRoleAuth(Long roleId, Long[] menusId);
/**
* 通过角色ID查询角色使用数量
*
* @param roleId 角色ID
* @return 结果
*/
int countUserRoleByRoleId(Long roleId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysRoleService.java
|
Java
|
unknown
| 2,497
|
package com.jcm.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jcm.system.domain.SysUserRole;
import java.util.List;
/**
* <p>
* 用户和角色关联关系表 服务类
* </p>
*
* @author 吕世昊
*/
public interface ISysUserRoleService extends IService<SysUserRole> {
/**
* 查询已分配用户角色列表
* 根据用户ID获取角色ID列表
* @param userId 用户ID
* @return
*/
public List<Integer> selectAllocatedList(Long userId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysUserRoleService.java
|
Java
|
unknown
| 527
|
package com.jcm.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jcm.system.api.domain.SysUser;
import java.util.List;
/**
* <p>
* 用户表 服务类
* </p>
*
* @author 吕世昊
*/
public interface ISysUserService extends IService<SysUser> {
/**
* 通过用户名查询用户
*
* @param username 用户名
* @return 用户对象信息
*/
public SysUser selectUserByUserName(String username);
/**
* 通过用户ID查询用户
*
* @param userId 用户ID
* @return 用户对象信息
*/
public SysUser selectUserById(Long userId);
/**
* 根据条件分页查询用户列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
List<SysUser> selectUserList(SysUser user);
/**
* 检查用户名是否独有
* @param user 用户
* @return 是或否
*/
boolean checkUserNameUnique(SysUser user);
/**
* 检查手机号是否独有
* @param user 用户
* @return 是或否
*/
boolean checkPhoneUnique(SysUser user);
/**
* 检查邮箱是否独有
* @param user 用户
* @return 是或否
*/
boolean checkEmailUnique(SysUser user);
/**
* 添加用户
* @param user 用户
* @return 成功的记录数
*/
int insertUser(SysUser user);
/**
* 禁用用户账号
* @param userId
* @return
*/
int disableUser(Long userId);
/**
* 根据ID删除用户
* @param userId
* @return
*/
int deleteUser(Long userId);
/**
* 根据用户ID重置密码
* @param user
* @return
*/
int resetUserPassword(SysUser user);
/**
* 校验用户是否允许操作
*
* @param user 用户信息
*/
void checkUserAllowed(Long user);
/**
* 修改用户信息
*
* @param user 用户信息
* @return 结果
*/
int updateUser(SysUser user);
/**
* 修改用户最后登录时间和登录IP
*
* @param sysUser 用户信息
* @return 结果
*/
int changeLoginInfo(SysUser sysUser);
/**
* 用户授权角色
*
* @param userId 用户ID
* @param roleIds 角色组
*/
int insertUserAuth(Long userId, Long[] roleIds);
List<SysUser> selectUserAll();
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysUserService.java
|
Java
|
unknown
| 2,404
|
package com.jcm.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jcm.system.domain.SysUserSetting;
/**
* <p>
* 用户前端样式设置表 服务类
* </p>
*
* @author 吕世昊
* @since 2024-12-18
*/
public interface ISysUserSettingService extends IService<SysUserSetting> {
int insertUserSetting(SysUserSetting userSetting);
SysUserSetting selectUserSettingByUserId(Long userId);
int updateUserSetting(SysUserSetting userSetting);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysUserSettingService.java
|
Java
|
unknown
| 498
|
package com.jcm.system.service;
import com.jcm.system.domain.SysUserTask;
import java.util.List;
/**
* taskService接口
*
* @author lvshihao
* @date 2025-01-13
*/
public interface ISysUserTaskService
{
/**
* 查询用户任务
*
* @param taskId 用户任务主键
* @return 用户任务
*/
public SysUserTask selectSysUserTaskByTaskId(Long taskId);
/**
* 查询用户任务列表
*
* @param sysUserTask 用户任务
* @return 用户任务集合
*/
public List<SysUserTask> selectSysUserTaskList(SysUserTask sysUserTask);
/**
* 新增用户任务
*
* @param sysUserTask 用户任务
* @return 结果
*/
public int insertSysUserTask(SysUserTask sysUserTask);
/**
* 修改用户任务
*
* @param sysUserTask 用户任务
* @return 结果
*/
public int updateSysUserTask(SysUserTask sysUserTask);
/**
* 批量删除用户任务
*
* @param taskIds 需要删除的用户任务主键集合
* @return 结果
*/
public int deleteSysUserTaskByTaskIds(Long[] taskIds);
/**
* 删除用户任务信息
*
* @param taskId 用户任务主键
* @return 结果
*/
public int deleteSysUserTaskByTaskId(Long taskId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ISysUserTaskService.java
|
Java
|
unknown
| 1,319
|
package com.jcm.system.service;
import com.jcm.system.domain.TxVip;
import java.util.List;
/**
* vipService接口
*
* @author lvshihao
* @date 2025-01-11
*/
public interface ITxVipService
{
/**
* 查询vip
*
* @param vipId vip主键
* @return vip
*/
public TxVip selectTxVipByVipId(Long vipId);
/**
* 查询vip列表
*
* @param txVip vip
* @return vip集合
*/
public List<TxVip> selectTxVipList(TxVip txVip);
/**
* 新增vip
*
* @param txVip vip
* @return 结果
*/
public int insertTxVip(TxVip txVip);
/**
* 修改vip
*
* @param txVip vip
* @return 结果
*/
public int updateTxVip(TxVip txVip);
/**
* 批量删除vip
*
* @param vipIds 需要删除的vip主键集合
* @return 结果
*/
public int deleteTxVipByVipIds(Long[] vipIds);
/**
* 删除vip信息
*
* @param vipId vip主键
* @return 结果
*/
public int deleteTxVipByVipId(Long vipId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/ITxVipService.java
|
Java
|
unknown
| 1,069
|
package com.jcm.system.service;
public interface SysCacheListService {
Object getRedisKeysByCacheName(String cacheName);
int deleteCacheName(String cacheName);
int deleteCacheKey(String keyName);
Object getRedisKeyDataByKeyName(String keyName);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/SysCacheListService.java
|
Java
|
unknown
| 267
|
package com.jcm.system.service;
import com.alibaba.fastjson2.JSONObject;
import java.util.List;
import java.util.Properties;
/**
* @author lvshihao
*/
public interface SysCacheMonitorService {
Properties getRedisBaseInfo();
List<JSONObject> getRedisInfo();
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/SysCacheMonitorService.java
|
Java
|
unknown
| 274
|
package com.jcm.system.service;
import java.util.Properties;
/**
* @author lvshihao
*/
public interface SysSystemMonitorService {
Properties getSystemBaseInfo();
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/SysSystemMonitorService.java
|
Java
|
unknown
| 173
|
package com.jcm.system.service.impl;
import com.jcm.system.mapper.SysRoleMenuMapper;
import com.jcm.system.service.ISysRoleMenuService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @author 吕世昊
*/
@Service
@AllArgsConstructor
public class ISysRoleMenuServiceImpl implements ISysRoleMenuService {
private final SysRoleMenuMapper sysRoleMenuMapper;
/**
* 根据角色id查询所拥有的菜单id集合
* @param roleId
* @return
*/
@Override
public List<Integer> queryMenuIdsByRoleId(Integer roleId) {
return sysRoleMenuMapper.queryMenuIdsByRoleId(roleId);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/ISysRoleMenuServiceImpl.java
|
Java
|
unknown
| 683
|
package com.jcm.system.service.impl;
import com.alibaba.fastjson2.JSONObject;
import com.jcm.common.log.constant.BusinessNameConstant;
import com.jcm.common.log.utils.OperLogCover;
import com.jcm.common.redis.service.RedisService;
import com.jcm.system.service.SysCacheListService;
import lombok.AllArgsConstructor;
import org.springframework.data.redis.connection.DataType;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
/**
* @author lvshihao
*/
@Service
@AllArgsConstructor
public class SysCacheListServiceImpl implements SysCacheListService {
private final RedisService redisService;
@Override
public Object getRedisKeysByCacheName(String cacheName) {
Set keys = redisService.redisTemplate.keys(cacheName + "*");
if(keys.size() == 0){
return null;
}
return keys.parallelStream().map(key -> {
JSONObject jsonObject = new JSONObject();
jsonObject.put("keyName", String.valueOf(key).replace(cacheName, ""));
return jsonObject;
}).collect(Collectors.toList());
}
@Override
public int deleteCacheName(String cacheName) {
Set keys = redisService.redisTemplate.keys(cacheName + "*");
OperLogCover.deleteLogMsg(BusinessNameConstant.CACHE_LIST,keys.size());
if(keys.size() > 0){
redisService.redisTemplate.delete(keys);
}
return keys.size();
}
@Override
public int deleteCacheKey(String keyName) {
if(!redisService.hasKey(keyName)){
return 0;
}else{
redisService.deleteObject(keyName);
OperLogCover.deleteLogMsg(BusinessNameConstant.CACHE_LIST,1);
return 1;
}
}
@Override
public Object getRedisKeyDataByKeyName(String keyName) {
if(!redisService.hasKey(keyName)){
return null;
}
DataType type = redisService.redisTemplate.type(keyName);
String typeName = type.name();
if(typeName.equals("STRING")){
Object cacheObject = redisService.getCacheObject(keyName);
return cacheObject;
}else if(typeName.equals("LIST")){
List<Object> cacheList = redisService.getCacheList(keyName);
return cacheList;
}else{
return null;
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysCacheListServiceImpl.java
|
Java
|
unknown
| 2,404
|
package com.jcm.system.service.impl;
import com.alibaba.fastjson2.JSONObject;
import com.jcm.common.redis.service.RedisService;
import com.jcm.system.service.SysCacheMonitorService;
import lombok.AllArgsConstructor;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
@Service
@AllArgsConstructor
public class SysCacheMonitorServiceImpl implements SysCacheMonitorService {
private final RedisService redisService;
@Override
public Properties getRedisBaseInfo() {
Properties baseInfo =new Properties();
redisService.redisTemplate.execute((RedisCallback<List<String>>) connection -> {
JSONObject serverInfo = new JSONObject();
Properties info = connection.info();
serverInfo.put("redis_version", info.get("redis_version"));
serverInfo.put("tcp_port", info.get("tcp_port"));
serverInfo.put("process_id", info.get("process_id"));
JSONObject memoryInfo = new JSONObject();
memoryInfo.put("used_memory", String.format("%.2fKB", Double.parseDouble((String) info.get("used_memory")) / 1000));
memoryInfo.put("used_memory_peak", String.format("%.2fKB", Double.parseDouble((String) info.get("used_memory_peak")) / 1000));
memoryInfo.put("used_memory_lua", String.format("%.2fKB", Double.parseDouble((String) info.get("used_memory_lua")) / 1000));
JSONObject statsInfo = new JSONObject();
statsInfo.put("connected_clients", info.get("connected_clients"));
statsInfo.put("total_connections_received", info.get("total_connections_received"));
statsInfo.put("total_commands_processed", info.get("total_commands_processed"));
JSONObject db0Info = new JSONObject();
Object db0 = info.get("db0");
Arrays.asList(String.valueOf(db0).split(",")).stream().forEach(item->{
String[] split = item.split("=");
db0Info.put(split[0], split[1]);
});
JSONObject otherInfo = new JSONObject();
otherInfo.put("os", info.get("os"));
otherInfo.put("role", info.get("role"));
otherInfo.put("redis_mode", info.get("redis_mode"));
otherInfo.put("uptime_in_days", "运行"+info.get("uptime_in_days")+"天");
otherInfo.put("uptime_in_seconds", info.get("uptime_in_seconds"));
otherInfo.put("cluster_enabled", info.get("cluster_enabled"));
otherInfo.put("expired_keys", info.get("expired_keys"));
otherInfo.put("maxmemory_policy", info.get("maxmemory_policy"));
otherInfo.put("master_replid", String.valueOf(info.get("master_replid")).substring(0,25)+"...");
otherInfo.put("run_id", String.valueOf(info.get("run_id")).substring(0,30)+"...");
JSONObject persistenceInfo = new JSONObject();
persistenceInfo.put("aof_enabled", info.get("aof_enabled"));
persistenceInfo.put("aof_last_bgrewrite_status", info.get("aof_last_bgrewrite_status"));
persistenceInfo.put("mem_aof_buffer", info.get("mem_aof_buffer"));
persistenceInfo.put("aof_last_rewrite_time_sec", info.get("aof_last_rewrite_time_sec"));
persistenceInfo.put("aof_rewrite_in_progress", info.get("aof_rewrite_in_progress"));
persistenceInfo.put("aof_last_write_status", info.get("aof_last_write_status"));
persistenceInfo.put("rdb_last_save_time", info.get("rdb_last_save_time"));
persistenceInfo.put("rdb_last_bgsave_status", info.get("rdb_last_bgsave_status"));
persistenceInfo.put("rdb_current_bgsave_time_sec", info.get("rdb_current_bgsave_time_sec"));
persistenceInfo.put("rdb_bgsave_in_progress", info.get("rdb_bgsave_in_progress"));
baseInfo.put("server", serverInfo);
baseInfo.put("memory", memoryInfo);
baseInfo.put("stats", statsInfo);
baseInfo.put("db0", db0Info);
baseInfo.put("other", otherInfo);
baseInfo.put("persistenceInfo", persistenceInfo);
return null;
});
return baseInfo;
}
@Override
public List<JSONObject> getRedisInfo() {
List<JSONObject> jsonObj = new ArrayList<>();
redisService.redisTemplate.execute((RedisCallback<List<String>>) connection -> {
Properties allInfo = connection.info();
allInfo.keySet().forEach(key->{
JSONObject jsonObject = new JSONObject();
String keyStr = String.valueOf(key);
String valueStr = String.valueOf(allInfo.get(key));
jsonObject.put("configName", keyStr);
jsonObject.put("configValue", valueStr);
jsonObj.add(jsonObject);
});
return null;
});
return jsonObj;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysCacheMonitorServiceImpl.java
|
Java
|
unknown
| 5,022
|
package com.jcm.system.service.impl;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.constant.CacheConstants;
import com.jcm.common.redis.service.RedisService;
import com.jcm.system.domain.SysDictData;
import com.jcm.system.mapper.SysDictDataMapper;
import com.jcm.system.service.ISysDictDataService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author 吕世昊
*/
@Service
@AllArgsConstructor
public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDictData> implements ISysDictDataService {
private final SysDictDataMapper sysDictDataMapper;
private final RedisService redisService;
@Override
public int insertDictData(SysDictData dictData) {
//插入数据
return sysDictDataMapper.insert(dictData);
}
@Override
public List<SysDictData> selectDictDataList(SysDictData dictType) {
return sysDictDataMapper.selectListByCondition(dictType);
}
@Override
public int deleteDictData(List<Long> dictDataIds) {
return sysDictDataMapper.deleteBatchIds(dictDataIds);
}
@Override
public List<JSONObject> getInfoList(List<String> names) {
//存放缓存中查到的字典值
List<JSONObject> dataList = new ArrayList<>();
for (String name : names) {
List<JSONObject> cacheList = redisService.getCacheList(CacheConstants.SYS_DICT_KEY + name);
dataList.addAll(cacheList);
}
return dataList;
}
private void loadDataToCache() {
Set keys = redisService.redisTemplate.keys(CacheConstants.SYS_DICT_KEY + "*");
if(keys.size()>0){
redisService.deleteObject(keys);
}
//获取全部的字典数据,加载并处理成JSONObject
List<SysDictData> infoListAll = sysDictDataMapper.getInfoList(null);
infoListAll.stream().map(dictData -> {
JSONObject jsonObject = JSONObject.parseObject(dictData.getExtra());
jsonObject.put("name", dictData.getName());
jsonObject.put("value", dictData.getValue());
jsonObject.put("description", dictData.getDescription());
return jsonObject;
}).collect(Collectors.groupingBy(json -> {
// 根据dictData.getName()获取名称作为分组的键，这里假设dictData是一个对象实例，有对应的getName()方法
return json.getString("name");
})).forEach((name, jsonList)->{
redisService.setCacheList(CacheConstants.SYS_DICT_KEY+name,jsonList);
});
}
@Override
public List<JSONObject> getInfo(String name) {
List<SysDictData> infoList = sysDictDataMapper.getInfoList(Collections.singletonList(name));
List<JSONObject> infoObjList = infoList.stream().map(dictData -> {
JSONObject jsonObject = JSONObject.parseObject(dictData.getExtra());
jsonObject.put("value", dictData.getValue());
jsonObject.put("description", dictData.getDescription());
return jsonObject;
}).collect(Collectors.toList());
return infoObjList;
}
@Override
public int updateDictData(SysDictData sysDictData) {
return sysDictDataMapper.updateById(sysDictData);
}
@Override
public void refreshDictDataCache() {
if(!redisService.hasKey(CacheConstants.SYS_DICT_KEY)){
redisService.deleteObject(CacheConstants.SYS_DICT_KEY);
}
loadDataToCache();
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysDictDataServiceImpl.java
|
Java
|
unknown
| 3,657
|
package com.jcm.system.service.impl;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.system.domain.SysDictData;
import com.jcm.system.domain.SysDictType;
import com.jcm.system.mapper.SysDictDataMapper;
import com.jcm.system.mapper.SysDictTypeMapper;
import com.jcm.system.service.ISysDictTypeService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
/**
* @author 吕世昊
*/
@Service
@AllArgsConstructor
public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDictType> implements ISysDictTypeService {
private final SysDictTypeMapper sysDictTypeMapper;
private final SysDictDataMapper sysDictDataMapper;
/**
* 根据条件分页查询字典配置项数据
* @param dictType 字典项信息
* @return 字典项数据集合信息
*/
@Override
public List<SysDictType> selectDictTypeList(SysDictType dictType) {
return this.lambdaQuery()
.like(StringUtils.isNotEmpty(dictType.getName()), SysDictType::getName,dictType.getName())
.like(StringUtils.isNotEmpty(dictType.getDescription()),SysDictType::getDescription,dictType.getDescription())
.eq(Objects.nonNull(dictType.getStatus()),SysDictType::getStatus,dictType.getStatus()).list();
}
/**
* 新增保存字典项信息
* @param dictType 字典项信息
* @return 结果
*/
@Transactional(rollbackFor = Exception.class)
@Override
public int insertDictType(SysDictType dictType) {
//插入数据
return sysDictTypeMapper.insert(dictType);
}
@Override
public List<SysDictType> selectDictTypeAndExtraAllList() {
return sysDictTypeMapper.selectDictTypeAndExtraAllList();
}
@Transactional(rollbackFor = Exception.class)
@Override
public int deleteDictType(List<Long> dictTypeIds) {
sysDictDataMapper.deleteByDictTypeIds(dictTypeIds);
return sysDictTypeMapper.deleteBatchIds(dictTypeIds);
}
@Transactional(rollbackFor = Exception.class)
@Override
public int updateDictType(SysDictType sysDictType) {
UpdateWrapper<SysDictType> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("dict_type_id", sysDictType.getDictTypeId());
//获取存在的额外参数名称
Set<String> extraSchemasNameSet = new HashSet<>();
JSONArray extraSchemasJson = JSONArray.parse(sysDictType.getExtraSchema());
extraSchemasJson.stream().forEach(extraSchemaJson->{
extraSchemasNameSet.add((String) JSONObject.from(extraSchemaJson).get("parameter"));
});
//查询配置项之前的所有配置值
QueryWrapper<SysDictData> queryWrapper =new QueryWrapper<>();
queryWrapper.eq("dict_type_id", sysDictType.getDictTypeId());
List<SysDictData> sysDictDataList = sysDictDataMapper.selectList(queryWrapper);
//如果配置项修改的时候删除了配置参数，那么配置值中的配置参数也会被删除
for (SysDictData sysDictData : sysDictDataList) {
JSONObject extraJson = JSONObject.parse(sysDictData.getExtra());
Set<String> extrasName = extraJson.keySet();
List<String> removeNameList = new ArrayList<>();
for (String name : extrasName) {
if (!extraSchemasNameSet.contains(name)){
removeNameList.add(name);
}
}
//删除配置项中不存在的配置参数
for(int i=0;i<removeNameList.size();i++){
extraJson.remove(removeNameList.get(i));
}
sysDictData.setExtra(extraJson.toString());
sysDictDataMapper.updateById(sysDictData);
}
return sysDictTypeMapper.update(sysDictType,updateWrapper);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysDictTypeServiceImpl.java
|
Java
|
unknown
| 4,229
|
package com.jcm.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.system.api.domain.SysLogininfor;
import com.jcm.system.mapper.SysLogininforMapper;
import com.jcm.system.service.ISysLogininforService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
/**
* logininforService业务层处理
*
* @author lvshihao
* @date 2025-01-11
*/
@Service
@AllArgsConstructor
public class SysLogininforServiceImpl extends ServiceImpl<SysLogininforMapper, SysLogininfor> implements ISysLogininforService {
private final SysLogininforMapper sysLogininforMapper;
/**
* 查询系统访问记录列表
*
* @param sysLogininfor 系统访问记录
* @return 系统访问记录
*/
@Override
public List<SysLogininfor> selectSysLogininforList(SysLogininfor sysLogininfor)
{
LambdaQueryWrapper<SysLogininfor> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.select(SysLogininfor::getInfoId, SysLogininfor::getUserName, SysLogininfor::getIpaddr, SysLogininfor::getLoginLocation, SysLogininfor::getBrowser, SysLogininfor::getOs, SysLogininfor::getStatus, SysLogininfor::getMsg, SysLogininfor::getLoginTime, SysLogininfor::getRemark, SysLogininfor::getCreator, SysLogininfor::getCreateTime, SysLogininfor::getUpdater, SysLogininfor::getUpdateTime, SysLogininfor::getDeleted );
queryWrapper.like( StringUtils.isNotEmpty(sysLogininfor.getUserName()) , SysLogininfor::getUserName, sysLogininfor.getUserName());
queryWrapper.eq( StringUtils.isNotEmpty(sysLogininfor.getIpaddr()) , SysLogininfor::getIpaddr, sysLogininfor.getIpaddr());
queryWrapper.eq( StringUtils.isNotEmpty(sysLogininfor.getStatus()) , SysLogininfor::getStatus, sysLogininfor.getStatus());
queryWrapper.eq( StringUtils.isNotEmpty(sysLogininfor.getOs()) , SysLogininfor::getOs, sysLogininfor.getOs());
if(Objects.nonNull(sysLogininfor.getParams())){
queryWrapper.ge(StringUtils.isNotNull(sysLogininfor.getParams().get("beginLoginTime")), SysLogininfor::getLoginTime,sysLogininfor.getParams().get("beginLoginTime"))
.le(Objects.nonNull(sysLogininfor.getParams())&&StringUtils.isNotNull(sysLogininfor.getParams().get("endLoginTime")),SysLogininfor::getLoginTime,sysLogininfor.getParams().get("endLoginTime"));
}
return sysLogininforMapper.selectList(queryWrapper);
}
/**
* 新增系统访问记录
*
* @param sysLogininfor 系统访问记录
* @return 结果
*/
@Override
public int insertSysLogininfor(SysLogininfor sysLogininfor)
{
return sysLogininforMapper.insert(sysLogininfor);
}
/**
* 批量删除系统访问记录
*
* @param infoIds 需要删除的系统访问记录主键
* @return 结果
*/
@Override
public int deleteSysLogininforByInfoIds(Long[] infoIds)
{
return sysLogininforMapper.deleteBatchIds(Arrays.asList(infoIds));
}
/**
* 删除系统访问记录信息
*
* @param infoId 系统访问记录主键
* @return 结果
*/
@Override
public int deleteSysLogininforByInfoId(Long infoId)
{
return sysLogininforMapper.deleteById(infoId);
}
@Override
public int clearLogininfor() {
sysLogininforMapper.clearLogininfor();
return 1;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysLogininforServiceImpl.java
|
Java
|
unknown
| 3,615
|
package com.jcm.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.constant.MenuConstant;
import com.jcm.common.core.constant.UserConstants;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.api.domain.SysUser;
import com.jcm.system.domain.SysMenu;
import com.jcm.system.domain.vo.MetaVo;
import com.jcm.system.domain.vo.RouterVo;
import com.jcm.system.mapper.SysMenuMapper;
import com.jcm.system.service.ISysMenuService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author 吕世昊
*/
@Service
@AllArgsConstructor
public class SysMenuServiceImpl extends ServiceImpl<SysMenuMapper, SysMenu> implements ISysMenuService {
private final SysMenuMapper sysMenuMapper;
/**
* 获取菜单数据权限
*
* @param sysUser 用户
* @return 菜单权限信息
*/
@Override
public Set<String> getMenuPermission(SysUser sysUser) {
Set<String> perms = new HashSet<String>();
// 管理员拥有所有权限
if (sysUser.isAdmin()) {
perms.add("*:*:*");
} else {
perms.addAll(selectMenuPermsByUserId(sysUser.getUserId()));
}
return perms;
}
/**
* 根据用户ID查询权限
*
* @param userId 用户ID
* @return 权限列表
*/
public Set<String> selectMenuPermsByUserId(Long userId){
return sysMenuMapper.selectMenuPermsByUserId(userId).stream()
.filter(StringUtils::isNotEmpty).map(String::trim).collect(Collectors.toSet());
}
/**
* 构建前端路由所需要的菜单
*
* @param menus 菜单列表
* @return 路由列表
*/
@Override
public List<RouterVo> buildMenus(List<SysMenu> menus, String parentPath) {
List<RouterVo> routers = new LinkedList<RouterVo>();
for (SysMenu menu : menus) {
RouterVo router = new RouterVo();
router.setMeta(new MetaVo(menu.getName(),menu.getVisible(),menu.getIsFrame(),menu.getIcon(), menu.getKeepAlive()));
List<SysMenu> cMenus = menu.getChildren();
//如果是外链
if(menu.getIsFrame()){
router.setPath(menu.getLink());
router.setComponent(UserConstants.LAYOUT);
}else {
if(MenuConstant.TYPE_DIR == menu.getType()){
router.setPath("/"+menu.getComponent());
router.setComponent(UserConstants.LAYOUT);
}else if(MenuConstant.TYPE_MENU == menu.getType() && menu.getParentId() != 0){
router.setName(menu.getComponent());
router.setPath("/"+parentPath+"/"+menu.getComponent());
router.setComponent("/"+parentPath+"/"+menu.getComponent()+"/index");
}else if(MenuConstant.TYPE_MENU == menu.getType() && menu.getParentId() == 0){
List<RouterVo> routerVos = new ArrayList<>();
RouterVo routerVo=new RouterVo();
routerVo.setPath("/index");
routerVo.setComponent("/"+menu.getComponent()+"/index");
routerVo.setMeta(router.getMeta());
if("home".equals(menu.getComponent())){
router.setPath("/");
router.setRedirect("/home");
routerVo.setName("home");
routerVo.setPath("/home");
}else{
routerVo.setName(menu.getComponent());
routerVo.setPath("/index");
router.setPath("/"+menu.getComponent());
}
routerVos.add(routerVo);
router.setComponent(UserConstants.LAYOUT);
router.setMeta(null);
router.setChildren(routerVos);
}
}
//如果还有子菜单，递归
if(StringUtils.isNotEmpty(cMenus)) {
router.setChildren(buildMenus(cMenus,menu.getComponent()));
}
//如果组件是空的
if(StringUtils.isEmpty(menu.getComponent())){
router.setComponent(UserConstants.LAYOUT);
}
routers.add(router);
}
routers.forEach(routerVo -> {
if(routerVo.getChildren()!=null &&routerVo.getChildren().size()>=1){
RouterVo routerVoChildren = routerVo.getChildren().get(0);
routerVo.setRedirect(routerVoChildren.getPath());
}
});
return routers;
}
/**
* 根据用户ID获取菜单树
*
* @param userId 用户ID
* @return 菜单树信息
*/
@Override
public List<SysMenu> selectMenuTreeByUserId(Long userId) {
List<SysMenu> menus = null;
if (SecurityUtils.isAdmin(userId)) {
menus = sysMenuMapper.selectMenuTreeAll(true);
} else {
menus = sysMenuMapper.selectMenuTreeByUserId(userId,true);
}
return getChildPerms(menus, 0);
}
@Override
public List<SysMenu> selectRouterTreeByUserId(Long userId) {
List<SysMenu> menus = null;
if (SecurityUtils.isAdmin(userId)) {
menus = sysMenuMapper.selectMenuTreeAll(null);
} else {
menus = sysMenuMapper.selectMenuTreeByUserId(userId,null);
}
return getChildPerms(menus, 0);
}
/**
* 根据父节点的ID获取所有子节点
*
* @param list 分类表
* @param parentId 传入的父节点ID
* @return String
*/
public List<SysMenu> getChildPerms(List<SysMenu> list, int parentId) {
List<SysMenu> returnList = new ArrayList<SysMenu>();
for (Iterator<SysMenu> iterator = list.iterator(); iterator.hasNext(); ) {
SysMenu t = (SysMenu) iterator.next();
// 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
if (t.getParentId() == parentId) {
recursionFn(list, t);
returnList.add(t);
}
}
return returnList;
}
/**
* 递归列表
*
* @param list 分类表
* @param t 子节点
*/
private void recursionFn(List<SysMenu> list, SysMenu t) {
// 得到子节点列表
List<SysMenu> childList = getChildList(list, t);
t.setChildren(childList);
for (SysMenu tChild : childList) {
if (hasChild(list, tChild)) {
recursionFn(list, tChild);
}
}
}
/**
* 判断是否有子节点
*/
private boolean hasChild(List<SysMenu> list, SysMenu t) {
return getChildList(list, t).size() > 0;
}
/**
* 得到子节点列表
*/
private List<SysMenu> getChildList(List<SysMenu> list, SysMenu t) {
List<SysMenu> tlist = new ArrayList<SysMenu>();
Iterator<SysMenu> it = list.iterator();
while (it.hasNext()) {
SysMenu n = (SysMenu) it.next();
if (n.getParentId().longValue() == t.getMenuId().longValue()) {
tlist.add(n);
}
}
return tlist;
}
@Override
public List<SysMenu> selectMenuAllTree(SysMenu sysMenu) {
List<SysMenu> allMenus = this.lambdaQuery()
.like(StringUtils.isNotEmpty(sysMenu.getName()), SysMenu::getName, sysMenu.getName())
.eq(Objects.nonNull(sysMenu.getStatus()), SysMenu::getStatus, sysMenu.getStatus())
.orderByAsc(SysMenu::getSort)
.list();
if (allMenus.isEmpty()) {
return new ArrayList<>();
}
List<SysMenu> rootMenus = findRootMenus(allMenus);
for (SysMenu rootMenu : rootMenus) {
addChildren(rootMenu, allMenus);
}
return rootMenus;
}
/**
* 新增菜单
* @param sysMenu 菜单
* @return
*/
@Override
public int insertMenu(SysMenu sysMenu) {
if(StringUtils.isNotEmpty(sysMenu.getComponent())){
sysMenu.setIsFrame(false);
}else{
sysMenu.setIsFrame(true);
}
return sysMenuMapper.insert(sysMenu);
}
/**
* 删除菜单通过id
* @param menuId
* @return
*/
@Override
public int deleteMenu(Long menuId) {
return sysMenuMapper.deleteById(menuId);
}
/**
* 修改菜单信息
* @param menu 菜单信息
* @return 结果
*/
@Override
public int updateMenu(SysMenu menu) {
UpdateWrapper<SysMenu> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("menu_id", menu.getMenuId());
return sysMenuMapper.update(menu,updateWrapper);
}
/**
* 获取新增菜单最后的sort值
* @param parentId 父菜单id
* @return 结果
*/
@Override
public Integer getMenuChildLastSort(Long parentId) {
return sysMenuMapper.selectMenuChildLastSort(parentId);
}
/**
* 获取首页动态图标名称
* @return 结果
*/
@Override
public String getHomeMenuIcon() {
LambdaQueryWrapper<SysMenu> lambdaQueryWrapper=new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(SysMenu::getName,"首页");
SysMenu sysMenu = sysMenuMapper.selectOne(lambdaQueryWrapper);
return sysMenu.getIcon();
}
/**
* 修改菜单及所有子菜单的状态/显示状态
* @param menu 父菜单对象
* @return
*/
@Override
public int changeStatusWithChildStatus(SysMenu menu) {
List<SysMenu> menus = sysMenuMapper.selectList(null);
List<SysMenu> menuList = getChildList(menus, menu);
//把当前菜单也添加进去
menuList.add(menu);
return sysMenuMapper.updateBatchById(menuList,menu.getStatus(),menu.getVisible());
}
/**
* 过滤菜单：遍历每个菜单项 menu，检查是否存在其他菜单项的 menuId 等于当前菜单项的 parentId。
* 收集结果：如果不存在这样的菜单项，则认为当前菜单项是根菜单，将其加入结果列表。
* @param menus 菜单项 menu对象集合
* @return
*/
private List<SysMenu> findRootMenus(List<SysMenu> menus) {
return menus.stream()
.filter(menu -> menus.stream().noneMatch(m -> m.getMenuId().equals(menu.getParentId())))
.collect(Collectors.toList());
}
/**
* 1：创建一个空的子菜单列表 children。
* 2：遍历所有菜单 allMenus。
* 3：检查当前菜单 menu 的 parentId 是否等于 parentMenu 的 menuId。
* 4：如果条件成立，将 menu 添加到 children 列表中。
* 5：递归调用 addChildren 方法为 menu 添加子菜单。
* 6：设置 parentMenu 的 children 属性为 children 列表。
* @param parentMenu 父菜单
* @param allMenus 需要遍历的菜单对象集合
*/
private void addChildren(SysMenu parentMenu, List<SysMenu> allMenus) {
List<SysMenu> children = new ArrayList<>();
for (SysMenu menu : allMenus) {
if (menu.getParentId()!= null && menu.getParentId().equals(parentMenu.getMenuId())) {
children.add(menu);
addChildren(menu, allMenus);
}
}
parentMenu.setChildren(children);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysMenuServiceImpl.java
|
Java
|
unknown
| 11,787
|
package com.jcm.system.service.impl;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.system.api.domain.SysOperLog;
import com.jcm.system.mapper.SysOperLogMapper;
import com.jcm.system.service.ISysOperLogService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Objects;
/**
* @author 吕世昊
*/
@Service
@AllArgsConstructor
public class SysOperLogServiceImpl extends ServiceImpl<SysOperLogMapper, SysOperLog> implements ISysOperLogService {
private final SysOperLogMapper sysOperLogMapper;
/**
* 新增操作日志
*
* @param operLog 操作日志对象
* @return 结果
*/
@Override
public int insertOperlog(SysOperLog operLog)
{
return sysOperLogMapper.insert(operLog);
}
@Override
public List<SysOperLog> selectOperLogList(SysOperLog sysOperLog) {
LambdaQueryChainWrapper<SysOperLog> queryChainWrapper = this.lambdaQuery()
.eq(StringUtils.isNotEmpty(sysOperLog.getOperName()), SysOperLog::getOperName, sysOperLog.getOperName())
.eq(StringUtils.isNotEmpty(sysOperLog.getTitle()), SysOperLog::getTitle, sysOperLog.getTitle())
.eq(StringUtils.isNotEmpty(sysOperLog.getBusinessName()), SysOperLog::getBusinessName, sysOperLog.getBusinessName())
.eq(StringUtils.isNotNull(sysOperLog.getStatus()), SysOperLog::getStatus, sysOperLog.getStatus())
.orderByDesc(SysOperLog::getRequestTime);
if(Objects.nonNull(sysOperLog.getParams())){
queryChainWrapper.ge(StringUtils.isNotNull(sysOperLog.getParams().get("beginRequestTime")),SysOperLog::getRequestTime,sysOperLog.getParams().get("beginRequestTime"))
.le(Objects.nonNull(sysOperLog.getParams())&&StringUtils.isNotNull(sysOperLog.getParams().get("endRequestTime")),SysOperLog::getRequestTime,sysOperLog.getParams().get("endRequestTime"));
}
return queryChainWrapper.list();
}
@Override
public int deleteOperLog(List<Long> operIds) {
return sysOperLogMapper.deleteBatchIds(operIds);
}
@Override
public int clearOperLog() {
sysOperLogMapper.clearOperLog();
return 1;
}
@Override
public List<String> nameOptionSelect() {
return sysOperLogMapper.nameOptionSelect();
}
@Override
public List<String> titleOptionSelect() {
return sysOperLogMapper.titleOptionSelect();
}
@Override
public List<String> businessNameOptionSelectByTitle(String title) {
return sysOperLogMapper.businessNameOptionSelectByTitle(title);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysOperLogServiceImpl.java
|
Java
|
unknown
| 2,850
|
package com.jcm.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.exception.ServiceException;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.system.api.domain.SysUser;
import com.jcm.system.domain.SysRole;
import com.jcm.system.domain.SysRoleMenu;
import com.jcm.system.mapper.SysRoleMapper;
import com.jcm.system.mapper.SysRoleMenuMapper;
import com.jcm.system.mapper.SysUserRoleMapper;
import com.jcm.system.service.ISysRoleService;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
/**
* @author 吕世昊
*/
@Service
@AllArgsConstructor
public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> implements ISysRoleService {
private final SysRoleMapper sysRoleMapper;
private final SysUserRoleMapper sysUserRoleMapper;
private final SysRoleMenuMapper sysRoleMenuMapper;
/**
* 根据用户ID查询角色权限
* @param userId 用户ID
* @return 权限列表
*/
public List<SysRole> selectRolePermissionByUserId(Long userId) {
return sysRoleMapper.selectRolePermissionByUserId(userId);
}
/**
* 校验角色名称是否唯一
* @param role 角色信息
* @return 结果
*/
@Override
public boolean checkRoleNameUnique(SysRole role)
{
List<SysRole> list = this.lambdaQuery().eq(StringUtils.isNotEmpty(role.getName()), SysRole::getName, role.getName()).list();
return list.size() == 0;
}
/**
* 校验角色权限是否唯一
* @param role 角色信息
* @return 结果
*/
@Override
public boolean checkRoleKeyUnique(SysRole role)
{
List<SysRole> list = this.lambdaQuery().eq(StringUtils.isNotEmpty(role.getCode()), SysRole::getCode, role.getCode()).list();
return list.size() == 0;
}
/**
* 根据条件分页查询角色数据
* @param role 角色信息
* @return 角色数据集合信息
*/
@Override
public List<SysRole> selectRoleList(SysRole role)
{
return this.lambdaQuery()
.like(StringUtils.isNotEmpty(role.getName()),SysRole::getName,role.getName())
.like(StringUtils.isNotEmpty(role.getCode()),SysRole::getCode,role.getCode())
.eq(StringUtils.isNotNull(role.getStatus()),SysRole::getStatus,role.getStatus())
.list();
}
/**
* 通过角色ID查询角色
* @param roleId 角色ID
* @return 角色对象信息
*/
@Override
public SysRole selectRoleById(Long roleId) {
return this.lambdaQuery().eq(Objects.nonNull(roleId), SysRole::getRoleId, roleId).one();
}
/**
* 新增保存角色信息
* @param role 角色信息
* @return 结果
*/
@Override
@Transactional(rollbackFor = Exception.class)
public int insertRole(SysRole role)
{
return sysRoleMapper.insert(role);
}
/**
* 校验角色是否允许操作
* @param role 角色信息
*/
@Override
public void checkRoleAllowed(SysRole role)
{
if (StringUtils.isNotNull(role.getRoleId()) && role.isAdmin())
{
throw new ServiceException("不允许操作超级管理员角色");
}
}
/**
* 修改角色状态
* @param role 角色信息
* @return 结果
*/
@Override
public int updateRoleStatus(SysRole role)
{
UpdateWrapper<SysRole> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("role_id", role.getRoleId()).set("status",1);
return sysRoleMapper.update(null, updateWrapper);
}
/**
* 修改角色信息
* @param role 角色信息
* @return 结果
*/
@Override
public int updateRole(SysRole role) {
UpdateWrapper<SysRole> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("role_id", role.getRoleId());
return sysRoleMapper.update(role, updateWrapper);
}
/**
* 删除角色信息
* @param roleIds 角色Id集合
* @return 结果
*/
@Override
public int deleteRole(List<Long> roleIds) {
for (Long roleId : roleIds)
{
checkRoleAllowed(new SysRole(roleId));
SysRole role = selectRoleById(roleId);
if (countUserRoleByRoleId(roleId) > 0)
{
throw new ServiceException(String.format("%1$s已分配,不能删除", role.getName()));
}
}
sysRoleMenuMapper.deleteByRoleIds(roleIds);
return sysRoleMapper.deleteBatchIds(roleIds);
}
/**
* 查询所有启用的角色
*
* @return 角色列表
*/
@Override
public List<SysRole> selectRoleAll() {
return this.lambdaQuery().eq(SysRole::getStatus,0).list();
}
@Transactional(rollbackFor = Exception.class)
@Override
public int insertRoleAuth(Long roleId, Long[] menusId) {
if(StringUtils.isEmpty(menusId)){
return 0;
}
//删除角色已经授权的所有菜单
LambdaQueryWrapper<SysRoleMenu> lambdaQueryWrapper=new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ObjectUtils.isNotEmpty(roleId),SysRoleMenu::getRoleId,roleId);
sysRoleMenuMapper.delete(lambdaQueryWrapper);
//重新新增角色下所有的菜单
List<SysRoleMenu> SysRoleMenus = new ArrayList<>();
Arrays.asList(menusId).forEach(menuId->{
SysRoleMenu sysUserRole=new SysRoleMenu();
sysUserRole.setRoleId(roleId);
sysUserRole.setMenuId(menuId);
SysRoleMenus.add(sysUserRole);
});
return sysRoleMenuMapper.batchRoleMenu(SysRoleMenus);
}
/**
* 通过角色ID查询角色使用数量
*
* @param roleId 角色ID
* @return 结果
*/
@Override
public int countUserRoleByRoleId(Long roleId)
{
return sysUserRoleMapper.countUserRoleByRoleId(roleId);
}
/**
* 获取角色数据权限
* @param user 用户
* @return 角色权限信息
*/
@Override
public Set<String> getRolePermission(SysUser user) {
Set<String> roles = new HashSet<String>();
// 管理员拥有所有权限
if (user.isAdmin()) {
roles.add("admin");
} else {
this.selectRolePermissionByUserId(user.getUserId()).stream()
.map(SysRole::getCode).filter(StringUtils::isNotNull)
.map(String::trim).forEach(roles::add);
}
return roles;
}
/**
* 批量删除角色信息
* @param roleIds 需要删除的角色ID
* @return 结果
*/
// @Override
// @Transactional(rollbackFor = Exception.class)
// public int deleteRoleByIds(Long[] roleIds)
// {
// for (Long roleId : roleIds)
// {
// checkRoleAllowed(new SysRole(roleId));
// SysRole role = selectRoleById(roleId);
// if (countUserRoleByRoleId(roleId) > 0)
// {
// throw new ServiceException(String.format("%1$s已分配,不能删除", role.getRoleName()));
// }
// }
// // 删除角色与菜单关联
// roleMenuMapper.deleteRoleMenu(roleIds);
// return roleMapper.deleteRoleByIds(roleIds);
// }
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysRoleServiceImpl.java
|
Java
|
unknown
| 7,657
|
package com.jcm.system.service.impl;
import com.alibaba.fastjson2.JSONObject;
import com.jcm.system.service.SysSystemMonitorService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.task.TaskExecutor;
import org.springframework.stereotype.Service;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.CentralProcessor.TickType;
import oshi.hardware.GlobalMemory;
import oshi.hardware.HardwareAbstractionLayer;
import oshi.software.os.OperatingSystem;
import oshi.util.FormatUtil;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.RuntimeMXBean;
import java.text.DecimalFormat;
import java.time.Duration;
import java.time.Instant;
import java.util.Properties;
import java.util.concurrent.CompletableFuture;
import static com.jcm.common.core.utils.system.OshiUtil.getFileSystem;
import static com.jcm.common.core.utils.system.OshiUtil.getProcesses;
@Slf4j
@AllArgsConstructor
@Service
public class SysSystemMonitorServiceImpl implements SysSystemMonitorService {
private final TaskExecutor taskExecutor;
@Override
public Properties getSystemBaseInfo() {
long startTime = System.currentTimeMillis();
Properties info=new Properties();
SystemInfo si = new SystemInfo();
// 获取操作系统实例，用于访问操作系统相关信息
OperatingSystem os = si.getOperatingSystem();
// 获取硬件抽象层实例，用于访问硬件相关信息
HardwareAbstractionLayer hal = si.getHardware();
CompletableFuture<Void> cpu = CompletableFuture.runAsync(() -> {
//cpu信息
info.put("cpu", getCpuInfo(si));
},taskExecutor);
CompletableFuture<Void> memory = CompletableFuture.runAsync(() -> {
//系统内存
info.put("memory", getMemoryInfo(si));
},taskExecutor);
CompletableFuture<Void> jvmMemory = CompletableFuture.runAsync(() -> {
//jvm内存
info.put("jvmMemory", getJvmMemoryInfo(si));
},taskExecutor);
CompletableFuture<Void> server = CompletableFuture.runAsync(() -> {
//服务器信息
info.put("server",getServerInfo(si));
},taskExecutor);
CompletableFuture<Void> processes = CompletableFuture.runAsync(() -> {
//获取进程
info.put("processes",getProcesses(os,hal.getMemory()));
},taskExecutor);
CompletableFuture<Void> fileSystem = CompletableFuture.runAsync(() -> {
//获取文件系统
info.put("fileSystem",getFileSystem(os.getFileSystem()));
},taskExecutor);
CompletableFuture.allOf(cpu,memory,jvmMemory,server,processes,fileSystem).join();
long endTime = System.currentTimeMillis();
log.debug("getSystemBaseInfo耗时"+(endTime-startTime));
return info;
}
/**
* 获取系统Cpu信息
* @param si
* @return
*/
private static JSONObject getCpuInfo(SystemInfo si){
JSONObject cpuInfo = new JSONObject();
// 获取CPU信息
CentralProcessor cpu = si.getHardware().getProcessor();
cpuInfo.put("Cpu核心数量: ",cpu.getPhysicalProcessorCount());
CentralProcessor processor = si.getHardware().getProcessor();
long[] prevTicks = processor.getSystemCpuLoadTicks();
try {
// 等待一段时间，例如1秒，以获取CPU使用率变化
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
long[] ticks = processor.getSystemCpuLoadTicks();
long user = ticks[CentralProcessor.TickType.USER.getIndex()] - prevTicks[TickType.USER.getIndex()];
long nice = ticks[TickType.NICE.getIndex()] - prevTicks[TickType.NICE.getIndex()];
long sys = ticks[TickType.SYSTEM.getIndex()] - prevTicks[TickType.SYSTEM.getIndex()];
long idle = ticks[TickType.IDLE.getIndex()] - prevTicks[TickType.IDLE.getIndex()];
long iowait = ticks[TickType.IOWAIT.getIndex()] - prevTicks[TickType.IOWAIT.getIndex()];
long irq = ticks[TickType.IRQ.getIndex()] - prevTicks[TickType.IRQ.getIndex()];
long softirq = ticks[TickType.SOFTIRQ.getIndex()] - prevTicks[TickType.SOFTIRQ.getIndex()];
long steal = ticks[TickType.STEAL.getIndex()] - prevTicks[TickType.STEAL.getIndex()];
long totalCpu = user + nice + sys + idle + iowait + irq + softirq + steal;
// 计算用户使用率，保留小数点后两位
double userUsage = ((double) user / totalCpu) * 100;
DecimalFormat userFormat = new DecimalFormat("#.##");
cpuInfo.put("用户使用率: ", userFormat.format(userUsage) + "%");
// 计算系统使用率，保留小数点后两位
double sysUsage;
if (totalCpu == 0) {
// 处理总CPU时间为0的情况，这里将使用率设为0
sysUsage = 0;
} else {
sysUsage = ((double) sys / totalCpu) * 100;
}
DecimalFormat sysFormat = new DecimalFormat("#.##");
cpuInfo.put("系统使用率: ", sysFormat.format(sysUsage) + "%");
// 计算当前空闲率，保留小数点后两位
double idleRate = ((double) idle / totalCpu) * 100;
DecimalFormat idleFormat = new DecimalFormat("#.##");
cpuInfo.put("当前空闲率: ", idleFormat.format(idleRate) + "%");
return cpuInfo;
}
/**
* 获取系统内存信息
* @param si
* @return
*/
private static JSONObject getMemoryInfo(SystemInfo si){
JSONObject memoryInfo = new JSONObject();
// 获取内存信息
GlobalMemory memory = si.getHardware().getMemory();
long pageSize = memory.getPageSize();
memoryInfo.put("内存页面大小: " , FormatUtil.formatBytes(pageSize));
// 将字节转换为MB（1MB = 1024 * 1024字节）
long totalMemoryInMB = memory.getTotal() / (1024 * 1024);
long availableMemoryInMB = memory.getAvailable() / (1024 * 1024);
// 计算内存使用率，保留小数点后2位
double memoryUsageRate = ((double) (memory.getTotal() - memory.getAvailable()) / memory.getTotal()) * 100;
DecimalFormat df = new DecimalFormat("#.##");
memoryInfo.put("系统总内存: ", totalMemoryInMB + "MB");
memoryInfo.put("系统已用内存: ", availableMemoryInMB + "MB");
memoryInfo.put("系统内存使用率: ", df.format(memoryUsageRate) + "%");
return memoryInfo;
}
/**
* 获取jvm内存信息
* @param si
* @return
*/
private static JSONObject getJvmMemoryInfo(SystemInfo si) {
JSONObject jvmMemoryInfo = new JSONObject();
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
// 获取RuntimeMXBean实例
RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
// 获取JVM启动时间（以毫秒为单位，从1970年1月1日00:00:00 UTC开始到JVM启动时刻的时间差）
long startTimeInMillis = runtimeMXBean.getStartTime();
// 获取当前时间（以毫秒为单位，从1970年1月1日00:00:00 UTC开始到当前时刻的时间差）
long currentTimeInMillis = System.currentTimeMillis();
// 将时长转换为更易读的格式，先转换为Duration对象
Instant startInstant = Instant.ofEpochMilli(startTimeInMillis);
Instant currentInstant = Instant.ofEpochMilli(currentTimeInMillis);
Duration duration = Duration.between(startInstant, currentInstant);
// 计算天数，通过总毫秒数除以一天包含的毫秒数（24 * 60 * 60 * 1000）
long days = duration.toMillis() / (24 * 60 * 60 * 1000);
long remainingMillis = duration.toMillis() % (24 * 60 * 60 * 1000);
long hours = remainingMillis / (60 * 60 * 1000);
long minutes = (remainingMillis / (60 * 1000)) % 60;
long seconds = (remainingMillis / 1000) % 60;
jvmMemoryInfo.put("JVM启动时长：", days + "天 " + hours + "小时 " + minutes + "分钟 " + seconds + "秒");
MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
// 将JVM堆内存总大小从字节转换为MB（1MB = 1024 * 1024字节）
long jvmTotalHeapMemoryInMB = heapMemoryUsage.getMax() / (1024 * 1024);
// 将JVM堆内存已使用大小从字节转换为MB
long jvmUsedHeapMemoryInMB = heapMemoryUsage.getUsed() / (1024 * 1024);
// 计算JVM堆内存使用率，保留小数点后2位
double jvmHeapMemoryUsageRate = ((double) heapMemoryUsage.getUsed() / heapMemoryUsage.getMax()) * 100;
DecimalFormat df = new DecimalFormat("#.##");
jvmMemoryInfo.put("JVM堆内存总大小: ", jvmTotalHeapMemoryInMB + "MB");
jvmMemoryInfo.put("JVM堆内存已使用大小: ", jvmUsedHeapMemoryInMB + "MB");
jvmMemoryInfo.put("JVM堆内存使用率: ", df.format(jvmHeapMemoryUsageRate) + "%");
return jvmMemoryInfo;
}
/**
* 获取服务器信息
* @param si
* @return
*/
private static JSONObject getServerInfo(SystemInfo si) {
JSONObject serverInfo = new JSONObject();
// 获取操作系统相关信息
OperatingSystem os = si.getOperatingSystem();
// 获取服务器名称
String hostname = os.getNetworkParams().getHostName();
String ipv4DefaultGateway = os.getNetworkParams().getIpv4DefaultGateway();
// 获取操作系统和系统架构信息
String osName = os.toString();
if (osName.length() > 25) {
osName = osName.substring(0, 25) + "...";
}
String osArch = os.getBitness() + "位";
// 创建一个Map或JSONObject来存储信息（这里使用Map，你可以根据需要转换为JSONObject）
serverInfo.put("服务器名称: ", hostname);
serverInfo.put("服务器IP: ", ipv4DefaultGateway);
serverInfo.put("操作系统: ", osName);
serverInfo.put("系统架构: ", osArch);
// 打印服务器信息
return serverInfo;
}
/**
* 获取Java虚拟机信息
* @param sigar
* @return
* @throws SigarException
*/
// private static JSONObject getJavaInfo(Sigar sigar) throws SigarException {
// // 获取Java名称（通过Java系统属性）
// String javaName = System.getProperty("java.vm.name");
// System.out.println("Java名称: " + javaName);
//
// // 获取Java版本（通过Java系统属性）
// String javaVersion = System.getProperty("java.version");
// System.out.println("Java版本: " + javaVersion);
//
// // 获取Java启动时间及运行时长
// RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
// long startTime = runtimeMXBean.getStartTime();
// long uptime = runtimeMXBean.getUptime();
//
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// Date startDate = new Date(startTime);
// System.out.println("启动时间: " + sdf.format(startDate));
//
// long hours = uptime / (1000 * 60 * 60);
// long minutes = (uptime / (1000 * 60)) % 60;
// long seconds = (uptime / 1000) % 60;
// System.out.println("运行时长: " + hours + "小时 " + minutes + "分钟 " + seconds + "秒");
//
// // 获取Java安装路径（通过Java系统属性，可能在不同环境下不太准确）
// String javaHome = System.getProperty("java.home");
// System.out.println("安装路径: " + javaHome);
//
// // 获取项目路径（较难准确获取，这里获取当前工作目录作为近似，不一定完全符合预期）
// String projectPath = System.getProperty("user.dir");
// System.out.println("项目路径: " + projectPath);
//
// // 获取运行参数（通过RuntimeMXBean）
// String argsStr = String.join(", ", runtimeMXBean.getInputArguments());
// System.out.println("运行参数: " + argsStr);
//
// try {
// // Sigar相关资源释放（如果不使用了建议关闭）
// sigar.close();
// } catch (SigarException e) {
// e.printStackTrace();
// }
// serverInfo.put("服务器名称: ", hostname);
// serverInfo.put("操作系统: ", os.getDescription());
// serverInfo.put("系统架构: ", os.getArch());
// return serverInfo;
// }
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysSystemMonitorServiceImpl.java
|
Java
|
unknown
| 12,695
|
package com.jcm.system.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.system.domain.SysUserRole;
import com.jcm.system.mapper.SysUserRoleMapper;
import com.jcm.system.service.ISysUserRoleService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @author 吕世昊
*/
@SuppressWarnings(value = "all")
@Service
@AllArgsConstructor
public class SysUserRoleServiceImpl extends ServiceImpl<SysUserRoleMapper, SysUserRole> implements ISysUserRoleService {
private final SysUserRoleMapper sysUserRoleMapper;
/**
* 根据用户ID获取角色ID列表
* @param userId 用户ID
* @return
*/
@Override
public List<Integer> selectAllocatedList(Long userId) {
return sysUserRoleMapper.selectAllocatedList(userId);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysUserRoleServiceImpl.java
|
Java
|
unknown
| 871
|
package com.jcm.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.constant.UserConstants;
import com.jcm.common.core.exception.ServiceException;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.system.api.domain.SysUser;
import com.jcm.system.domain.SysUserRole;
import com.jcm.system.domain.SysUserSetting;
import com.jcm.system.mapper.SysUserMapper;
import com.jcm.system.mapper.SysUserRoleMapper;
import com.jcm.system.service.ISysUserService;
import com.jcm.system.service.ISysUserSettingService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
/**
* @author 吕世昊
*/
@Service
@AllArgsConstructor
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements ISysUserService {
private final SysUserMapper sysUserMapper;
private final SysUserRoleMapper sysUserRoleMapper;
private final ISysUserSettingService sysUserSettingService;
/**
* 通过用户名查询用户
* @param userName 用户名
* @return 用户对象信息
*/
@Override
public SysUser selectUserByUserName(String userName) {
return this.lambdaQuery().eq(SysUser::getUsername, userName).one();
}
/**
* 根据ID查询用户信息
* @param userId 用户ID
* @return 用户信息
*/
@Override
public SysUser selectUserById(Long userId) {
return this.lambdaQuery()
.select(SysUser.class, (e) -> !"password".equals(e.getColumn()))
.eq(SysUser::getUserId, userId).one();
}
/**
* 根据条件进行查找用户列表
* @param user 用户信息
* @return
*/
@Override
public List<SysUser> selectUserList(SysUser user) {
return this.lambdaQuery().select(SysUser.class, (e) -> !"password".equals(e.getColumn()))
.like(StringUtils.isNotEmpty(user.getUsername()), SysUser::getUsername, user.getUsername())
.like(StringUtils.isNotEmpty(user.getNickname()), SysUser::getNickname, user.getNickname())
.eq(StringUtils.isNotNull(user.getStatus()), SysUser::getStatus, user.getStatus())
.like(StringUtils.isNotEmpty(user.getMobile()), SysUser::getMobile, user.getMobile())
.like(StringUtils.isNotEmpty(user.getEmail()), SysUser::getEmail, user.getEmail()).list();
}
/**
* 检查用户名是否重复
* @param user 用户
* @return
*/
@Override
public boolean checkUserNameUnique(SysUser user) {
List<SysUser> list = this.lambdaQuery().eq(StringUtils.isNotEmpty(user.getUsername()), SysUser::getUsername, user.getUsername()).list();
return list.size() == 0;
}
/**
* 检查手机号是否重复
* @param user 用户
* @return
*/
@Override
public boolean checkPhoneUnique(SysUser user) {
List<SysUser> list = this.lambdaQuery()
.eq(StringUtils.isNotEmpty(user.getMobile()), SysUser::getMobile, user.getMobile())
.eq(SysUser::getDeleted, 0)
.list();
return list.size() == 0;
}
/**
* 检查邮箱是否重复
* @param user 用户
* @return
*/
@Override
public boolean checkEmailUnique(SysUser user) {
List<SysUser> list = this.lambdaQuery().eq(StringUtils.isNotEmpty(user.getEmail()), SysUser::getEmail, user.getEmail()).list();
return list.size() == 0;
}
/**
* 新增用户
* @param user 用户
* @return
*/
@Transactional(rollbackFor = Exception.class)
@Override
public int insertUser(SysUser user) {
SysUserSetting sysUserSetting = new SysUserSetting();
int insert = sysUserMapper.insert(user);
sysUserSetting.setUserId(user.getUserId());
sysUserSettingService.insertUserSetting(sysUserSetting);
return insert;
}
/**
* 禁用用户账号
* @param userId
*/
@Override
public int disableUser(Long userId) {
UpdateWrapper<SysUser> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("user_id", userId).set("status", UserConstants.USER_DISABLE);
return sysUserMapper.update(null, updateWrapper);
}
/**
* 删除用户
* @param userId
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public int deleteUser(Long userId) {
sysUserRoleMapper.deleteUserRoleByUserId(userId);
return sysUserMapper.deleteById(userId);
}
/**
* 重置密码
* @param user
* @return
*/
@Override
public int resetUserPassword(SysUser user) {
UpdateWrapper<SysUser> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("user_id", user.getUserId()).set("password", user.getPassword());
return sysUserMapper.update(null, updateWrapper);
}
/**
* 校验用户是否允许操作
* @param userId 用户信息id
*/
@Override
public void checkUserAllowed(Long userId) {
if (StringUtils.isNotNull(userId) && 1L == userId) {
throw new ServiceException("不允许操作超级管理员用户");
}
}
/**
* 修改保存用户信息
* @param user 用户信息
* @return 结果
*/
@Override
public int updateUser(SysUser user)
{
UpdateWrapper<SysUser> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("user_id", user.getUserId())
.set("nickname", user.getNickname())
.set("mobile", user.getMobile())
.set("email", user.getEmail());
return sysUserMapper.update(null, updateWrapper);
}
/**
* 修改用户最后登录时间和IP
* @param user 用户信息
* @return
*/
@Override
public int changeLoginInfo(SysUser user) {
UpdateWrapper<SysUser> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("user_id", user.getUserId())
.set("login_ip", user.getLoginIp())
.set("login_date", user.getLoginDate());
return sysUserMapper.update(null, updateWrapper);
}
/**
* 用户授权角色
* @param userId 用户ID
* @param roleIds 角色组
*/
@Override
@Transactional(rollbackFor = Exception.class)
public int insertUserAuth(Long userId, Long[] roleIds)
{
sysUserRoleMapper.deleteUserRoleByUserId(userId);
return insertUserRole(userId, roleIds);
}
@Override
public List<SysUser> selectUserAll() {
LambdaQueryWrapper<SysUser> lambdaQueryWrapper=new LambdaQueryWrapper<>();
lambdaQueryWrapper.select(SysUser::getUserId,SysUser::getUsername);
lambdaQueryWrapper.eq(SysUser::getDeleted,0);
lambdaQueryWrapper.eq(SysUser::getStatus,UserConstants.USER_NORMAL);
return baseMapper.selectList(lambdaQueryWrapper);
}
/**
* 新增用户角色信息
* @param userId 用户ID
* @param roleIds 角色组
*/
public int insertUserRole(Long userId, Long[] roleIds)
{
if (StringUtils.isEmpty(roleIds)){
return 0;
}
// 新增用户与角色管理
List<SysUserRole> list = new ArrayList<SysUserRole>();
for (Long roleId : roleIds)
{
SysUserRole ur = new SysUserRole();
ur.setUserId(userId);
ur.setRoleId(roleId);
list.add(ur);
}
return sysUserRoleMapper.batchUserRole(list);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysUserServiceImpl.java
|
Java
|
unknown
| 7,855
|
package com.jcm.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.system.domain.SysUserSetting;
import com.jcm.system.mapper.SysUserSettingMapper;
import com.jcm.system.service.ISysUserSettingService;
import org.springframework.stereotype.Service;
/**
* <p>
* 用户前端样式设置表 服务实现类
* </p>
*
* @author 吕世昊
* @since 2024-12-18
*/
@Service
public class SysUserSettingServiceImpl extends ServiceImpl<SysUserSettingMapper, SysUserSetting> implements ISysUserSettingService {
@Override
public int insertUserSetting(SysUserSetting userSetting) {
userSetting.setTheme(0).setThemeColor("#2174FF").setNavigationBar(true).setTabs(true).setTabsIcon(true).setBreadcrumb(true)
.setMenu(true).setCopyright(true).setWatermark(true).setWeakColor(false).setGrayscale(false).setBlur(false).setContrast(false).setHueRotate(false).setSaturate(false).setDataLoading(false).setSize(10);
return this.baseMapper.insert(userSetting);
}
/**
* 查询当前用户的前端设置信息
* @param userId 用户ID
* @return
*/
@Override
public SysUserSetting selectUserSettingByUserId(Long userId) {
LambdaQueryWrapper<SysUserSetting> lambdaQueryWrapper=new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(StringUtils.isNotNull(userId),SysUserSetting::getUserId,userId);
return this.baseMapper.selectOne(lambdaQueryWrapper);
}
/**
* 修改当前用户的前端设置信息
* @param userSetting
* @return
*/
@Override
public int updateUserSetting(SysUserSetting userSetting) {
LambdaQueryWrapper<SysUserSetting> lambdaQueryWrapper=new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(StringUtils.isNotNull(userSetting.getUserId()),SysUserSetting::getUserId,userSetting.getUserId());
return this.baseMapper.update(userSetting,lambdaQueryWrapper);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysUserSettingServiceImpl.java
|
Java
|
unknown
| 2,089
|
package com.jcm.system.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.system.domain.SysUserTask;
import com.jcm.system.mapper.SysUserTaskMapper;
import com.jcm.system.service.ISysUserTaskService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List;
/**
* taskService业务层处理
*
* @author lvshihao
* @date 2025-01-13
*/
@Service
@AllArgsConstructor
public class SysUserTaskServiceImpl extends ServiceImpl<SysUserTaskMapper, SysUserTask> implements ISysUserTaskService {
private final SysUserTaskMapper sysUserTaskMapper;
/**
* 查询用户任务
*
* @param taskId 用户任务主键
* @return 用户任务
*/
@Override
public SysUserTask selectSysUserTaskByTaskId(Long taskId)
{
return sysUserTaskMapper.selectById(taskId);
}
/**
* 查询用户任务列表
*
* @param sysUserTask 用户任务
* @return 用户任务
*/
@Override
public List<SysUserTask> selectSysUserTaskList(SysUserTask sysUserTask)
{
return sysUserTaskMapper.selectList(sysUserTask);
}
/**
* 新增用户任务
*
* @param sysUserTask 用户任务
* @return 结果
*/
@Override
public int insertSysUserTask(SysUserTask sysUserTask)
{
return sysUserTaskMapper.insert(sysUserTask);
}
/**
* 修改用户任务
*
* @param sysUserTask 用户任务
* @return 结果
*/
@Override
public int updateSysUserTask(SysUserTask sysUserTask)
{
return sysUserTaskMapper.updateById(sysUserTask);
}
/**
* 批量删除用户任务
*
* @param taskIds 需要删除的用户任务主键
* @return 结果
*/
@Override
public int deleteSysUserTaskByTaskIds(Long[] taskIds)
{
return sysUserTaskMapper.deleteBatchIds(Arrays.asList(taskIds));
}
/**
* 删除用户任务信息
*
* @param taskId 用户任务主键
* @return 结果
*/
@Override
public int deleteSysUserTaskByTaskId(Long taskId)
{
return sysUserTaskMapper.deleteById(taskId);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/SysUserTaskServiceImpl.java
|
Java
|
unknown
| 2,253
|
package com.jcm.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.system.domain.TxVip;
import com.jcm.system.mapper.TxVipMapper;
import com.jcm.system.service.ITxVipService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List;
/**
* vipService业务层处理
*
* @author lvshihao
* @date 2025-01-11
*/
@Service
@AllArgsConstructor
public class TxVipServiceImpl extends ServiceImpl<TxVipMapper, TxVip> implements ITxVipService {
private final TxVipMapper txVipMapper;
/**
* 查询vip
*
* @param vipId vip主键
* @return vip
*/
@Override
public TxVip selectTxVipByVipId(Long vipId)
{
return txVipMapper.selectById(vipId);
}
/**
* 查询vip列表
*
* @param txVip vip
* @return vip
*/
@Override
public List<TxVip> selectTxVipList(TxVip txVip)
{
LambdaQueryWrapper<TxVip> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.select(TxVip::getVipId, TxVip::getXyName, TxVip::getStartingTime, TxVip::getStopingTime, TxVip::getPurchaseDays, TxVip::getUnitType, TxVip::getStatus, TxVip::getLoginMethod, TxVip::getLoginAccount, TxVip::getCreator, TxVip::getCreateTime, TxVip::getUpdater, TxVip::getUpdateTime, TxVip::getRemark, TxVip::getDeleted );
queryWrapper.like( StringUtils.isNotEmpty(txVip.getXyName()) , TxVip::getXyName, txVip.getXyName());
queryWrapper.ge( StringUtils.isNotNull(txVip.getStartingTime()), TxVip::getStartingTime, txVip.getStartingTime());
queryWrapper.le( StringUtils.isNotNull(txVip.getStopingTime()), TxVip::getStopingTime, txVip.getStopingTime());
queryWrapper.eq( StringUtils.isNotEmpty(txVip.getPurchaseDays()) , TxVip::getPurchaseDays, txVip.getPurchaseDays());
queryWrapper.eq( StringUtils.isNotEmpty(txVip.getUnitType()) , TxVip::getUnitType, txVip.getUnitType());
queryWrapper.eq( StringUtils.isNotEmpty(txVip.getLoginMethod()) , TxVip::getLoginMethod, txVip.getLoginMethod());
return txVipMapper.selectList(queryWrapper);
}
/**
* 新增vip
*
* @param txVip vip
* @return 结果
*/
@Override
public int insertTxVip(TxVip txVip)
{
return txVipMapper.insert(txVip);
}
/**
* 修改vip
*
* @param txVip vip
* @return 结果
*/
@Override
public int updateTxVip(TxVip txVip)
{
return txVipMapper.updateById(txVip);
}
/**
* 批量删除vip
*
* @param vipIds 需要删除的vip主键
* @return 结果
*/
@Override
public int deleteTxVipByVipIds(Long[] vipIds)
{
return txVipMapper.deleteBatchIds(Arrays.asList(vipIds));
}
/**
* 删除vip信息
*
* @param vipId vip主键
* @return 结果
*/
@Override
public int deleteTxVipByVipId(Long vipId)
{
return txVipMapper.deleteById(vipId);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/service/impl/TxVipServiceImpl.java
|
Java
|
unknown
| 3,161
|
CONTAINER_NAME=market
IMAGE_NAME=system/market:1.0-SNAPSHOT
PORT=8091
echo "容器部署开始 ${CONTAINER_NAME}"
# 停止容器
docker stop ${CONTAINER_NAME}
# 删除容器
docker rm ${CONTAINER_NAME}
# 启动容器
docker run --name ${CONTAINER_NAME} \
-p ${PORT}:${PORT} \
-d ${IMAGE_NAME}
echo "容器部署成功 ${CONTAINER_NAME}"
docker logs -f ${CONTAINER_NAME}
|
2202_75314946/big-market
|
docs/dev-ops/app/start.sh
|
Shell
|
unknown
| 375
|
docker stop market
|
2202_75314946/big-market
|
docs/dev-ops/app/stop.sh
|
Shell
|
unknown
| 18
|
/*
Navicat Premium Data Transfer
Source Server : 127.0.0.1
Source Server Type : MySQL
Source Server Version : 50639
Source Host : localhost:3306
Source Schema : road-map
Target Server Type : MySQL
Target Server Version : 50639
File Encoding : 65001
Date: 15/07/2023 09:26:39
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
CREATE database if NOT EXISTS `xfg_frame_archetype` default character set utf8mb4 collate utf8mb4_0900_ai_ci;
use `xfg_frame_archetype`;
-- ----------------------------
-- Table structure for employee
-- ----------------------------
DROP TABLE IF EXISTS `employee`;
CREATE TABLE `employee` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`employee_number` varchar(16) NOT NULL DEFAULT '' COMMENT '雇员ID',
`employee_name` varchar(32) NOT NULL DEFAULT '' COMMENT '雇员姓名',
`employee_level` varchar(8) NOT NULL DEFAULT '' COMMENT '雇员级别',
`employee_title` varchar(16) NOT NULL DEFAULT '' COMMENT '雇员岗位Title',
`create_time` datetime NOT NULL COMMENT '创建时间',
`update_time` datetime NOT NULL COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `idx_employee_number` (`employee_number`)
) ENGINE=InnoDB AUTO_INCREMENT=40 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of employee
-- ----------------------------
BEGIN;
INSERT INTO `employee` VALUES (1, '10000001', 'sXvfDpsWnJdLsCVk64tJgw==', 'T-3', '中级工程师', '2023-07-14 15:26:26', '2023-07-14 15:26:26');
INSERT INTO `employee` VALUES (2, '10000010', 'sXvfDpsWnJdLsCVk64tJgw==', 'T2', '见习工程师', '2023-07-14 15:34:40', '2023-07-14 15:34:40');
INSERT INTO `employee` VALUES (3, '10000011', 'sXvfDpsWnJdLsCVk64tJgw==', 'T2', '见习工程师', '2023-07-14 15:34:40', '2023-07-14 15:34:40');
INSERT INTO `employee` VALUES (4, '10000012', 'sXvfDpsWnJdLsCVk64tJgw==', 'T2', '见习工程师', '2023-07-14 15:34:40', '2023-07-14 15:34:40');
INSERT INTO `employee` VALUES (5, '10000013', 'sXvfDpsWnJdLsCVk64tJgw==', 'T2', '见习工程师', '2023-07-14 15:34:40', '2023-07-14 15:34:40');
INSERT INTO `employee` VALUES (6, '10000014', 'sXvfDpsWnJdLsCVk64tJgw==', 'T2', '见习工程师', '2023-07-14 15:34:40', '2023-07-14 15:34:40');
INSERT INTO `employee` VALUES (9, '10000002', 'sXvfDpsWnJdLsCVk64tJgw==', 'T2', '见习工程师', '2023-07-15 07:42:52', '2023-07-15 07:42:52');
INSERT INTO `employee` VALUES (22, '10000015', 'hMCgLG6WV3CsNBQ1UD6PEQ==', 'T2', '见习工程师', '2023-07-15 08:02:31', '2023-07-15 08:02:31');
INSERT INTO `employee` VALUES (23, '10000016', 'hMCgLG6WV3CsNBQ1UD6PEQ==', 'T2', '见习工程师', '2023-07-15 08:02:31', '2023-07-15 08:02:31');
INSERT INTO `employee` VALUES (24, '10000017', 'hMCgLG6WV3CsNBQ1UD6PEQ==', 'T2', '见习工程师', '2023-07-15 08:02:31', '2023-07-15 08:02:31');
INSERT INTO `employee` VALUES (39, '10000022', 'GyG+V0r6mBCNsdusuKl03g==', 'T1', '实习工程师', '2023-07-15 09:17:49', '2023-07-15 09:17:49');
COMMIT;
-- ----------------------------
-- Table structure for employee_salary
-- ----------------------------
DROP TABLE IF EXISTS `employee_salary`;
CREATE TABLE `employee_salary` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`employee_number` varchar(16) NOT NULL DEFAULT '' COMMENT '雇员编号',
`salary_total_amount` decimal(8,2) NOT NULL COMMENT '薪资总额',
`salary_merit_amount` decimal(8,2) NOT NULL COMMENT '绩效工资',
`salary_base_amount` decimal(8,2) NOT NULL COMMENT '基础工资',
`create_time` datetime NOT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`),
KEY `idx_employee_number` (`employee_number`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of employee_salary
-- ----------------------------
BEGIN;
INSERT INTO `employee_salary` VALUES (1, '10000001', 5100.00, 1020.00, 4080.00, '2023-07-14 16:09:06', '2023-07-14 16:09:06');
INSERT INTO `employee_salary` VALUES (2, '10000010', 5000.00, 1000.00, 4000.00, '2023-07-14 16:17:10', '2023-07-14 16:17:10');
INSERT INTO `employee_salary` VALUES (3, '10000011', 5000.00, 1000.00, 4000.00, '2023-07-14 16:17:10', '2023-07-14 16:17:10');
INSERT INTO `employee_salary` VALUES (4, '10000012', 5000.00, 1000.00, 4000.00, '2023-07-14 16:17:10', '2023-07-14 16:17:10');
INSERT INTO `employee_salary` VALUES (5, '10000013', 5000.00, 1000.00, 4000.00, '2023-07-14 16:17:10', '2023-07-14 16:17:10');
INSERT INTO `employee_salary` VALUES (6, '10000014', 5000.00, 1000.00, 4000.00, '2023-07-14 16:17:10', '2023-07-14 16:17:10');
INSERT INTO `employee_salary` VALUES (8, '10000022', 100.00, 10.00, 90.00, '2023-07-15 09:17:49', '2023-07-15 09:17:49');
COMMIT;
-- ----------------------------
-- Table structure for employee_salary_adjust
-- ----------------------------
DROP TABLE IF EXISTS `employee_salary_adjust`;
CREATE TABLE `employee_salary_adjust` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`employee_number` varchar(16) NOT NULL DEFAULT '' COMMENT '雇员编号',
`adjust_order_id` varchar(32) NOT NULL DEFAULT '' COMMENT '调薪单号',
`adjust_total_amount` decimal(8,2) NOT NULL COMMENT '总额调薪',
`adjust_base_amount` decimal(8,2) NOT NULL COMMENT '基础调薪',
`adjust_merit_amount` decimal(8,2) NOT NULL COMMENT '绩效调薪',
`create_time` datetime NOT NULL COMMENT '创建时间',
`update_time` datetime NOT NULL COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `idx_order_id` (`adjust_order_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of employee_salary_adjust
-- ----------------------------
BEGIN;
INSERT INTO `employee_salary_adjust` VALUES (1, '10000001', '109089990198888811', 1000.00, 800.00, 200.00, '2023-07-14 16:55:53', '2023-07-14 16:55:53');
INSERT INTO `employee_salary_adjust` VALUES (2, '10000001', '100908977676001', 100.00, 20.00, 80.00, '2023-07-14 21:57:39', '2023-07-14 21:57:39');
COMMIT;
|
2202_75314946/big-market
|
docs/dev-ops/mysql/sql/xfg-frame-archetype.sql
|
PLpgSQL
|
unknown
| 6,002
|
# 基础镜像
FROM openjdk:8-jre-slim
# 作者
MAINTAINER xiaofuge
# 配置
ENV PARAMS=""
# 时区
ENV TZ=PRC
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 添加应用
ADD target/market-app-app.jar /market-app-app.jar
ENTRYPOINT ["sh","-c","java -jar $JAVA_OPTS /market-app-app.jar $PARAMS"]
|
2202_75314946/big-market
|
market-app/Dockerfile
|
Dockerfile
|
unknown
| 333
|
# 普通镜像构建，随系统版本构建 amd/arm
docker build -t system/market-app:1.0-SNAPSHOT -f ./Dockerfile .
# 兼容 amd、arm 构建镜像
# docker buildx build --load --platform liunx/amd64,linux/arm64 -t xiaofuge/xfg-frame-archetype-app:1.0 -f ./Dockerfile . --push
|
2202_75314946/big-market
|
market-app/build.sh
|
Shell
|
unknown
| 280
|
package org.example;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@Configurable
public class Application {
public static void main(String[] args){
SpringApplication.run(Application.class);
}
}
|
2202_75314946/big-market
|
market-app/src/main/java/org/example/Application.java
|
Java
|
unknown
| 377
|
package org.example.config;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;
@Configuration
public class GuavaConfig {
@Bean(name = "cache")
public Cache<String, String> cache() {
return CacheBuilder.newBuilder()
.expireAfterWrite(3, TimeUnit.SECONDS)
.build();
}
}
|
2202_75314946/big-market
|
market-app/src/main/java/org/example/config/GuavaConfig.java
|
Java
|
unknown
| 508
|
package org.example.config;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import java.util.concurrent.*;
@Slf4j
@EnableAsync
@Configuration
@EnableConfigurationProperties(ThreadPoolConfigProperties.class)
public class ThreadPoolConfig {
@Bean
@ConditionalOnMissingBean(ThreadPoolExecutor.class)
public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties properties) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
// 实例化策略
RejectedExecutionHandler handler;
switch (properties.getPolicy()){
case "AbortPolicy":
handler = new ThreadPoolExecutor.AbortPolicy();
break;
case "DiscardPolicy":
handler = new ThreadPoolExecutor.DiscardPolicy();
break;
case "DiscardOldestPolicy":
handler = new ThreadPoolExecutor.DiscardOldestPolicy();
break;
case "CallerRunsPolicy":
handler = new ThreadPoolExecutor.CallerRunsPolicy();
break;
default:
handler = new ThreadPoolExecutor.AbortPolicy();
break;
}
// 创建线程池
return new ThreadPoolExecutor(properties.getCorePoolSize(),
properties.getMaxPoolSize(),
properties.getKeepAliveTime(),
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(properties.getBlockQueueSize()),
Executors.defaultThreadFactory(),
handler);
}
}
|
2202_75314946/big-market
|
market-app/src/main/java/org/example/config/ThreadPoolConfig.java
|
Java
|
unknown
| 1,917
|
package org.example.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
@Data
@ConfigurationProperties(prefix = "thread.pool.executor.config", ignoreInvalidFields = true)
public class ThreadPoolConfigProperties {
/** 核心线程数 */
private Integer corePoolSize = 20;
/** 最大线程数 */
private Integer maxPoolSize = 200;
/** 最大等待时间 */
private Long keepAliveTime = 10L;
/** 最大队列数 */
private Integer blockQueueSize = 5000;
/*
* AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。
* DiscardPolicy：直接丢弃任务，但是不会抛出异常
* DiscardOldestPolicy：将最早进入队列的任务删除，之后再尝试加入队列的任务被拒绝
* CallerRunsPolicy：如果任务添加线程池失败，那么主线程自己执行该任务
* */
private String policy = "AbortPolicy";
}
|
2202_75314946/big-market
|
market-app/src/main/java/org/example/config/ThreadPoolConfigProperties.java
|
Java
|
unknown
| 961
|
/**
* 1. 用于管理引入的Jar所需的资源启动或者初始化处理
* 2. 如果有AOP切面，可以再建一个aop包，来写切面逻辑
*/
package org.example.config;
|
2202_75314946/big-market
|
market-app/src/main/java/org/example/config/package-info.java
|
Java
|
unknown
| 183
|
/**
* 应用启动层，注意Application所在的包路径，是在上一层。这样才能扫描到其他 module
* */
package org.example;
|
2202_75314946/big-market
|
market-app/src/main/java/org/example/package-info.java
|
Java
|
unknown
| 142
|
/**
* 外部接口适配器层；当需要调用外部接口时，则创建出这一层，并定义接口，之后由基础设施层的 adapter 层具体实现
*/
package org.example.domain.xxx.adapter;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/xxx/adapter/package-info.java
|
Java
|
unknown
| 204
|
/**
* 聚合对象；
* 1. 聚合实体和值对象
* 2. 聚合是聚合的对象，和提供基础处理对象的方法。但不建议在聚合中引入仓储和接口来做过大的逻辑。而这些复杂的操作应该放到service中处理
* 3. 对象名称 XxxAggregate
*/
package org.example.domain.xxx.model.aggregate;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/xxx/model/aggregate/package-info.java
|
Java
|
unknown
| 331
|
/**
* 实体对象；
* 1. 一般和数据库持久化对象1v1的关系，但因各自开发系统的不同，也有1vn的可能。
* 2. 如果是老系统改造，那么旧的库表冗余了太多的字段，可能会有nv1的情况
* 3. 对象名称 XxxEntity
*/
package org.example.domain.xxx.model.entity;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/xxx/model/entity/package-info.java
|
Java
|
unknown
| 315
|
/**
* 值对象；
* 1. 用于描述对象属性的值，如一个库表中有json后者一个字段多个属性信息的枚举对象
* 2. 对象名称如；XxxVO
*/
package org.example.domain.xxx.model.valobj;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/xxx/model/valobj/package-info.java
|
Java
|
unknown
| 214
|
/**
* 仓储服务
* 1. 定义仓储接口，之后由基础设施层做具体实现
*/
package org.example.domain.xxx.repository;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/xxx/repository/package-info.java
|
Java
|
unknown
| 133
|
package org.example.domain.xxx.service;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/xxx/service/package-info.java
|
Java
|
unknown
| 39
|
/**
* 聚合对象；
* 1. 聚合实体和值对象
* 2. 聚合是聚合的对象，和提供基础处理对象的方法。但不建议在聚合中引入仓储和接口来做过大的逻辑。而这些复杂的操作应该放到service中处理
* 3. 对象名称 XxxAggregate
*/
package org.example.domain.yyy.model.aggregate;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/yyy/model/aggregate/package-info.java
|
Java
|
unknown
| 331
|
/**
* 实体对象；
* 1. 一般和数据库持久化对象1v1的关系，但因各自开发系统的不同，也有1vn的可能。
* 2. 如果是老系统改造，那么旧的库表冗余了太多的字段，可能会有nv1的情况
* 3. 对象名称 XxxEntity
*/
package org.example.domain.yyy.model.entity;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/yyy/model/entity/package-info.java
|
Java
|
unknown
| 315
|
/**
* 值对象；
* 1. 用于描述对象属性的值，如一个库表中有json后者一个字段多个属性信息的枚举对象
* 2. 对象名称如；XxxVO
*/
package org.example.domain.yyy.model.valobj;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/yyy/model/valobj/package-info.java
|
Java
|
unknown
| 214
|
/**
* 仓储服务
* 1. 定义仓储接口，之后由基础设施层做具体实现
*/
package org.example.domain.yyy.repository;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/yyy/repository/package-info.java
|
Java
|
unknown
| 133
|
package org.example.domain.yyy.service;
|
2202_75314946/big-market
|
market-domain/src/main/java/org/example/domain/yyy/service/package-info.java
|
Java
|
unknown
| 39
|
package org.example.infrastructure.gateway.adapter;
|
2202_75314946/big-market
|
market-infrastructure/src/main/java/org/example/infrastructure/gateway/adapter/package-info.java
|
Java
|
unknown
| 51
|
package org.example.infrastructure.gateway.api;
|
2202_75314946/big-market
|
market-infrastructure/src/main/java/org/example/infrastructure/gateway/api/package-info.java
|
Java
|
unknown
| 47
|
package org.example.infrastructure.gateway.dto;
|
2202_75314946/big-market
|
market-infrastructure/src/main/java/org/example/infrastructure/gateway/dto/package-info.java
|
Java
|
unknown
| 47
|
/**
* DAO 接口；IXxxDao
*/
package org.example.infrastructure.persistent.dao;
|
2202_75314946/big-market
|
market-infrastructure/src/main/java/org/example/infrastructure/persistent/dao/package-info.java
|
Java
|
unknown
| 82
|
/**
* 持久化对象；XxxPO 最后的 PO 是大写，UserPO
*/
package org.example.infrastructure.persistent.po;
|
2202_75314946/big-market
|
market-infrastructure/src/main/java/org/example/infrastructure/persistent/po/package-info.java
|
Java
|
unknown
| 116
|
/**
* 仓储实现；用于实现 domain 中定义的仓储接口，如；IXxxRepository 在 Repository 中调用服务
*/
package org.example.infrastructure.persistent.repository;
|
2202_75314946/big-market
|
market-infrastructure/src/main/java/org/example/infrastructure/persistent/repository/package-info.java
|
Java
|
unknown
| 182
|
/**
* HTTP 接口服务
*/
package org.example.trigger.http;
|
2202_75314946/big-market
|
market-trigger/src/main/java/org/example/trigger/http/package-info.java
|
Java
|
unknown
| 62
|
/**
* 任务服务，可以选择使用 Spring 默认提供的 Schedule https://bugstack.cn/md/road-map/quartz.html
*/
package org.example.trigger.job;
|
2202_75314946/big-market
|
market-trigger/src/main/java/org/example/trigger/job/package-info.java
|
Java
|
unknown
| 153
|
/**
* 监听服务；在单体服务中，解耦流程。类似MQ的使用，如Spring的Event，Guava的事件总线都可以。如果使用了 Redis 那么也可以有发布/订阅使用。
* Guava：https://bugstack.cn/md/road-map/guava.html
*/
package org.example.trigger.listener;
|
2202_75314946/big-market
|
market-trigger/src/main/java/org/example/trigger/listener/package-info.java
|
Java
|
unknown
| 288
|
package org.example.types.common;
public class Constants {
public final static String SPLIT = ",";
}
|
2202_75314946/big-market
|
market-types/src/main/java/org/example/types/common/Constants.java
|
Java
|
unknown
| 108
|
package org.example.types.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
@AllArgsConstructor
@NoArgsConstructor
@Getter
public enum ResponseCode {
SUCCESS("0000", "成功"),
UN_ERROR("0001", "未知失败"),
ILLEGAL_PARAMETER("0002", "非法参数"),
;
private String code;
private String info;
}
|
2202_75314946/big-market
|
market-types/src/main/java/org/example/types/enums/ResponseCode.java
|
Java
|
unknown
| 375
|
package org.example.types.exception;
import lombok.Data;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode(callSuper = true)
@Data
public class AppException extends RuntimeException {
private static final long serialVersionUID = 5317680961212299217L;
/** 异常码 */
private String code;
/** 异常信息 */
private String info;
public AppException(String code) {
this.code = code;
}
public AppException(String code, Throwable cause) {
this.code = code;
super.initCause(cause);
}
public AppException(String code, String message) {
this.code = code;
this.info = message;
}
public AppException(String code, String message, Throwable cause) {
this.code = code;
this.info = message;
super.initCause(cause);
}
@Override
public String toString() {
return "org.example.x.api.types.exception.XApiException{" +
"code='" + code + '\'' +
", info='" + info + '\'' +
'}';
}
}
|
2202_75314946/big-market
|
market-types/src/main/java/org/example/types/exception/AppException.java
|
Java
|
unknown
| 1,061
|
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const cors = require('cors');
const bodyParser = require('body-parser');
const sqlite3 = require('sqlite3').verbose();
const path = require('path');
const app = express();
const server = http.createServer(app);
const io = socketIo(server, {
cors: {
origin: "*",
methods: ["GET", "POST"]
}
});
// 中间件
app.use(cors());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
// 数据库初始化
const db = new sqlite3.Database('./agriculture.db');
// 创建数据表
db.serialize(() => {
// 大棚信息表
db.run(`CREATE TABLE IF NOT EXISTS greenhouses (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
crop_type TEXT NOT NULL,
location TEXT,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
)`);
// 传感器数据表
db.run(`CREATE TABLE IF NOT EXISTS sensor_data (
id INTEGER PRIMARY KEY AUTOINCREMENT,
greenhouse_id INTEGER,
soil_temperature REAL,
soil_humidity REAL,
air_co2 REAL,
light_intensity REAL,
recorded_at DATETIME DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (greenhouse_id) REFERENCES greenhouses (id)
)`);
// 设备控制记录表
db.run(`CREATE TABLE IF NOT EXISTS device_controls (
id INTEGER PRIMARY KEY AUTOINCREMENT,
greenhouse_id INTEGER,
device_type TEXT,
action TEXT,
status TEXT,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (greenhouse_id) REFERENCES greenhouses (id)
)`);
// 阈值配置表
db.run(`CREATE TABLE IF NOT EXISTS threshold_configs (
id INTEGER PRIMARY KEY AUTOINCREMENT,
greenhouse_id INTEGER,
crop_type TEXT,
soil_temp_min REAL,
soil_temp_max REAL,
soil_humidity_min REAL,
soil_humidity_max REAL,
co2_min REAL,
co2_max REAL,
light_min REAL,
light_max REAL,
FOREIGN KEY (greenhouse_id) REFERENCES greenhouses (id)
)`);
});
// 模拟传感器数据生成
function generateSensorData() {
return {
soilTemperature: Math.random() * 10 + 20, // 20-30°C
soilHumidity: Math.random() * 30 + 40, // 40-70%
airCo2: Math.random() * 500 + 400, // 400-900 ppm
lightIntensity: Math.random() * 5000 + 5000 // 5000-10000 lux
};
}
// 获取作物默认阈值配置
function getDefaultThresholds(cropType) {
const thresholds = {
'tomato': {
soil_temp_min: 22, soil_temp_max: 28,
soil_humidity_min: 60, soil_humidity_max: 80,
co2_min: 400, co2_max: 800,
light_min: 6000, light_max: 9000
},
'cucumber': {
soil_temp_min: 20, soil_temp_max: 26,
soil_humidity_min: 65, soil_humidity_max: 85,
co2_min: 350, co2_max: 750,
light_min: 5500, light_max: 8500
},
'lettuce': {
soil_temp_min: 18, soil_temp_max: 24,
soil_humidity_min: 70, soil_humidity_max: 90,
co2_min: 400, co2_max: 700,
light_min: 4000, light_max: 7000
}
};
return thresholds[cropType] || thresholds['tomato'];
}
// API路由
// 获取所有大棚
app.get('/api/greenhouses', (req, res) => {
db.all('SELECT * FROM greenhouses ORDER BY created_at DESC', (err, rows) => {
if (err) {
res.status(500).json({ error: err.message });
return;
}
res.json(rows);
});
});
// 添加大棚
app.post('/api/greenhouses', (req, res) => {
const { name, crop_type, location } = req.body;
db.run('INSERT INTO greenhouses (name, crop_type, location) VALUES (?, ?, ?)',
[name, crop_type, location], function(err) {
if (err) {
res.status(500).json({ error: err.message });
return;
}
// 添加默认阈值配置
const thresholds = getDefaultThresholds(crop_type);
db.run(`INSERT INTO threshold_configs
(greenhouse_id, crop_type, soil_temp_min, soil_temp_max, soil_humidity_min, soil_humidity_max, co2_min, co2_max, light_min, light_max)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
[this.lastID, crop_type, ...Object.values(thresholds)]);
res.json({ id: this.lastID, name, crop_type, location });
});
});
// 获取大棚的传感器数据
app.get('/api/greenhouses/:id/sensor-data', (req, res) => {
const { id } = req.params;
const limit = req.query.limit || 50;
db.all('SELECT * FROM sensor_data WHERE greenhouse_id = ? ORDER BY recorded_at DESC LIMIT ?',
[id, limit], (err, rows) => {
if (err) {
res.status(500).json({ error: err.message });
return;
}
res.json(rows);
});
});
// 获取阈值配置
app.get('/api/greenhouses/:id/thresholds', (req, res) => {
const { id } = req.params;
db.get('SELECT * FROM threshold_configs WHERE greenhouse_id = ?', [id], (err, row) => {
if (err) {
res.status(500).json({ error: err.message });
return;
}
res.json(row);
});
});
// 更新阈值配置
app.put('/api/greenhouses/:id/thresholds', (req, res) => {
const { id } = req.params;
const thresholds = req.body;
db.run(`UPDATE threshold_configs SET
soil_temp_min = ?, soil_temp_max = ?,
soil_humidity_min = ?, soil_humidity_max = ?,
co2_min = ?, co2_max = ?,
light_min = ?, light_max = ?
WHERE greenhouse_id = ?`,
[...Object.values(thresholds), id], function(err) {
if (err) {
res.status(500).json({ error: err.message });
return;
}
res.json({ success: true });
});
});
// 控制设备
app.post('/api/greenhouses/:id/control', (req, res) => {
const { id } = req.params;
const { device_type, action } = req.body;
db.run('INSERT INTO device_controls (greenhouse_id, device_type, action, status) VALUES (?, ?, ?, ?)',
[id, device_type, action, 'completed'], function(err) {
if (err) {
res.status(500).json({ error: err.message });
return;
}
// 通过Socket通知前端
io.emit('deviceControl', {
greenhouseId: id,
deviceType: device_type,
action:
|
2203_75618979/Agriculture
|
server/index.js
|
JavaScript
|
unknown
| 5,943
|
import { hapTasks } from '@ohos/hvigor-ohos-plugin';
export default {
system: hapTasks, /* Built-in plugin of Hvigor. It cannot be modified. */
plugins: [] /* Custom plugin to extend the functionality of Hvigor. */
}
|
2201_76010299/napi_function_demo
|
entry/hvigorfile.ts
|
TypeScript
|
unknown
| 227
|
# the minimum version of CMake.
cmake_minimum_required(VERSION 3.5.0)
project(crossModule2)
set(NATIVERENDER_ROOT_PATH ${CMAKE_CURRENT_SOURCE_DIR})
if(DEFINED PACKAGE_FIND_FILE)
include(${PACKAGE_FIND_FILE})
endif()
include_directories(${NATIVERENDER_ROOT_PATH}
${NATIVERENDER_ROOT_PATH}/include)
add_library(entry SHARED napi_init.cpp napi_har.cpp)
target_link_libraries(entry PUBLIC libace_napi.z.so)
|
2201_76010299/napi_function_demo
|
entry/src/main/cpp/CMakeLists.txt
|
CMake
|
unknown
| 430
|
#include "napi/native_api.h"
#include "napi_har.h"
double harNativeAdd(double a, double b) {
return a + b;
}
// [End harNativeAdd_start]
// [Start set_start]
// staticModule\src\main\cpp\napi_har.cpp
void setHarEnv(napi_env env) {
g_main_env = env;
}
// [End set_start]
// [Start har_add_start]
// staticModule\src\main\cpp\napi_har.cpp
napi_value harArkTSAdd(double a, double b) {
napi_env env = g_main_env;
napi_value module;
napi_status status = napi_load_module_with_info(env, "entry/src/main/ets/utils/Util", "com.example.crossmodule/entry", &module);
// if(napi_invalid_arg==status)
// {
// napi_value result;
// napi_create_double(env,8, &result);
// return result;
// }
if (napi_ok != status) {
return 0;
}
napi_value addFunc;
napi_get_named_property(env, module, "add", &addFunc);
napi_value addResult;
napi_value argv[2] = {nullptr, nullptr};
napi_create_double(env, a, &argv[0]);
napi_create_double(env, b, &argv[1]);
napi_call_function(env, module, addFunc, 2, argv, &addResult);
return addResult;
}
|
2201_76010299/napi_function_demo
|
entry/src/main/cpp/napi_har.cpp
|
C++
|
unknown
| 1,126
|
#ifndef CROSSMODULEREFERENCE_NAPI_HAR_H
#define CROSSMODULEREFERENCE_NAPI_HAR_H
#include <js_native_api_types.h>
#include <node_api.h> // 或者使用你自己的头文件
#include <stdio.h>
// 声明函数 harArkTSAdd
// [StartExclude napi_har_start]
static napi_env g_main_env;
void setHarEnv(napi_env env);
// [EndExclude napi_har_start]
double harNativeAdd(double a, double b);
napi_value harArkTSAdd(double a, double b);
#endif
|
2201_76010299/napi_function_demo
|
entry/src/main/cpp/napi_har.h
|
C
|
unknown
| 434
|
#include "napi/native_api.h"
#include "napi_har.h"
static napi_value Add(napi_env env, napi_callback_info info)
{
size_t argc = 2;
napi_value args[2] = {nullptr};
napi_get_cb_info(env, info, &argc, args , nullptr, nullptr);
napi_valuetype valuetype0;
napi_typeof(env, args[0], &valuetype0);
napi_valuetype valuetype1;
napi_typeof(env, args[1], &valuetype1);
double value0;
napi_get_value_double(env, args[0], &value0);
double value1;
napi_get_value_double(env, args[1], &value1);
napi_value sum;
napi_create_double(env, value0 + value1, &sum);
return sum;
}
static napi_value invokeHarArkTS(napi_env env, napi_callback_info info)
{
size_t argc = 2;
napi_value args[2] = {nullptr};
napi_get_cb_info(env, info, &argc, args , nullptr, nullptr);
napi_valuetype valuetype0;
napi_typeof(env, args[0], &valuetype0);
napi_valuetype valuetype1;
napi_typeof(env, args[1], &valuetype1);
double value0;
napi_get_value_double(env, args[0], &value0);
double value1;
napi_get_value_double(env, args[1], &value1);
return harArkTSAdd(value0, value1);
}
EXTERN_C_START
static napi_value Init(napi_env env, napi_value exports)
{
napi_property_descriptor desc[] = {
{ "add", nullptr, Add, nullptr, nullptr, nullptr, napi_default, nullptr },
{ "invokeHarArkTS", nullptr, invokeHarArkTS, nullptr, nullptr, nullptr, napi_default, nullptr }
};
napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
setHarEnv(env);
return exports;
}
EXTERN_C_END
static napi_module demoModule = {
.nm_version = 1,
.nm_flags = 0,
.nm_filename = nullptr,
.nm_register_func = Init,
.nm_modname = "entry",
.nm_priv = ((void*)0),
.reserved = { 0 },
};
extern "C" __attribute__((constructor)) void RegisterEntryModule(void)
{
napi_module_register(&demoModule);
}
|
2201_76010299/napi_function_demo
|
entry/src/main/cpp/napi_init.cpp
|
C++
|
unknown
| 1,950
|
import { appTasks } from '@ohos/hvigor-ohos-plugin';
export default {
system: appTasks, /* Built-in plugin of Hvigor. It cannot be modified. */
plugins: [] /* Custom plugin to extend the functionality of Hvigor. */
}
|
2201_76010299/napi_function_demo
|
hvigorfile.ts
|
TypeScript
|
unknown
| 227
|
/**
* BH1750光照强度传感器驱动
* 使用I2C接口通信
*/
#include "bh1750.h"
#include "stdio.h"
// I2C超时定义
#define I2C_TIMEOUT 10000
// 延时函数
static void Delay_us(uint32_t us) {
uint32_t count = us * 8; // 72MHz时钟
while (count--) {
__NOP();
}
}
// 等待I2C事件
static uint8_t I2C_WaitEvent(I2C_TypeDef* I2Cx, uint32_t event) {
uint32_t timeout = I2C_TIMEOUT;
while (!I2C_CheckEvent(I2Cx, event)) {
if (--timeout == 0) return 0;
}
return 1;
}
// BH1750初始化
void BH1750_Init(void) {
// 上电
BH1750_Power_On();
// 延时等待稳定
Delay_us(20000); // 20ms
// 设置为连续高分辨率模式
BH1750_Set_Mode(BH1750_CMD_CONT_H_MODE);
// 延时等待第一次测量完成
Delay_us(120000); // 120ms
printf("BH1750光照传感器初始化完成\r\n");
}
// 设置测量模式
uint8_t BH1750_Set_Mode(uint8_t mode) {
// 发送起始信号
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
// 发送设备地址
I2C_Send7bitAddress(I2C1, BH1750_I2C_ADDR, I2C_Direction_Transmitter);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) return 0;
// 发送命令
I2C_SendData(I2C1, mode);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return 0;
// 发送停止信号
I2C_GenerateSTOP(I2C1, ENABLE);
return 1;
}
// 上电
uint8_t BH1750_Power_On(void) {
return BH1750_Set_Mode(BH1750_CMD_POWER_ON);
}
// 断电
uint8_t BH1750_Power_Down(void) {
return BH1750_Set_Mode(BH1750_CMD_POWER_DOWN);
}
// 复位
uint8_t BH1750_Reset(void) {
return BH1750_Set_Mode(BH1750_CMD_RESET);
}
// 设置测量时间
uint8_t BH1750_Set_Measurement_Time(uint8_t time) {
uint8_t high_time, low_time;
// 计算高字节和低字节
high_time = (0x40 | (time >> 5));
low_time = (0x60 | (time & 0x1F));
// 发送高字节
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
I2C_Send7bitAddress(I2C1, BH1750_I2C_ADDR, I2C_Direction_Transmitter);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) return 0;
I2C_SendData(I2C1, high_time);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return 0;
I2C_GenerateSTOP(I2C1, ENABLE);
// 延时
Delay_us(1000);
// 发送低字节
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
I2C_Send7bitAddress(I2C1, BH1750_I2C_ADDR, I2C_Direction_Transmitter);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) return 0;
I2C_SendData(I2C1, low_time);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return 0;
I2C_GenerateSTOP(I2C1, ENABLE);
return 1;
}
// 读取光照强度
uint16_t BH1750_Read_Lux(void) {
uint8_t rx_data[2];
uint16_t raw_data;
float lux;
// 根据当前模式等待测量完成
Delay_us(120000); // 120ms (高分辨率模式)
// 发送起始信号
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
// 发送设备地址 (读取模式)
I2C_Send7bitAddress(I2C1, BH1750_I2C_ADDR, I2C_Direction_Receiver);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) return 0;
// 读取高字节
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)) return 0;
rx_data[0] = I2C_ReceiveData(I2C1);
// 读取低字节 (不发送ACK)
I2C_AcknowledgeConfig(I2C1, DISABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)) return 0;
rx_data[1] = I2C_ReceiveData(I2C1);
// 发送停止信号
I2C_GenerateSTOP(I2C1, ENABLE);
// 重新使能ACK
I2C_AcknowledgeConfig(I2C1, ENABLE);
// 组合数据
raw_data = (rx_data[0] << 8) | rx_data[1];
// 计算光照强度 (1.2 / 1.0 是测量时间系数)
lux = (float)raw_data / 1.2;
printf("光照强度: %.0f lux\r\n", lux);
return (uint16_t)lux;
}
// 简化的读取函数 (适用于连续模式)
uint16_t BH1750_Read_Lux_Simple(void) {
uint8_t rx_data[2];
uint16_t raw_data;
float lux;
// 直接读取数据 (假设已经处于连续模式)
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
I2C_Send7bitAddress(I2C1, BH1750_I2C_ADDR, I2C_Direction_Receiver);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) return 0;
// 读取高字节
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)) return 0;
rx_data[0] = I2C_ReceiveData(I2C1);
// 读取低字节
I2C_AcknowledgeConfig(I2C1, DISABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)) return 0;
rx_data[1] = I2C_ReceiveData(I2C1);
I2C_GenerateSTOP(I2C1, ENABLE);
I2C_AcknowledgeConfig(I2C1, ENABLE);
// 计算光照强度
raw_data = (rx_data[0] << 8) | rx_data[1];
lux = (float)raw_data / 1.2;
return (uint16_t)lux;
}
|
2203_75618979/Agriculture1
|
bh1750.c
|
C
|
unknown
| 5,284
|
/**
* BH1750光照强度传感器驱动头文件
* 使用I2C接口通信
*/
#ifndef __BH1750_H
#define __BH1750_H
#include "stm32f10x.h"
// BH1750 I2C地址
#define BH1750_I2C_ADDR 0x23 // 7位地址 (ADDR引脚接地)
#define BH1750_I2C_ADDR_ALT 0x5C // 备用地址 (ADDR引脚接VCC)
// BH1750命令定义
#define BH1750_CMD_POWER_DOWN 0x00
#define BH1750_CMD_POWER_ON 0x01
#define BH1750_CMD_RESET 0x07
#define BH1750_CMD_CONT_H_MODE 0x10 // 连续高分辨率模式 (1lx, 120ms)
#define BH1750_CMD_CONT_H_MODE2 0x11 // 连续高分辨率模式2 (0.5lx, 120ms)
#define BH1750_CMD_CONT_L_MODE 0x13 // 连续低分辨率模式 (4lx, 16ms)
#define BH1750_CMD_ONE_H_MODE 0x20 // 单次高分辨率模式 (1lx, 120ms)
#define BH1750_CMD_ONE_H_MODE2 0x21 // 单次高分辨率模式2 (0.5lx, 120ms)
#define BH1750_CMD_ONE_L_MODE 0x23 // 单次低分辨率模式 (4lx, 16ms)
// 测量时间寄存器
#define BH1750_MTREG_HIGH 0x40
#define BH1750_MTREG_LOW 0x60
// 函数声明
void BH1750_Init(void);
uint16_t BH1750_Read_Lux(void);
uint8_t BH1750_Set_Mode(uint8_t mode);
uint8_t BH1750_Power_On(void);
uint8_t BH1750_Power_Down(void);
uint8_t BH1750_Reset(void);
uint8_t BH1750_Set_Measurement_Time(uint8_t time);
#endif
|
2203_75618979/Agriculture1
|
bh1750.h
|
C
|
unknown
| 1,284
|
/**
* ESP8266 WiFi模块驱动
* 使用UART串口通信
*/
#include "esp8266.h"
#include "stdio.h"
#include "string.h"
// 使用USART2连接ESP8266 (PA2=TX, PA3=RX)
#define ESP8266_USART USART2
// 接收缓冲区
#define RX_BUFFER_SIZE 1024
static char rx_buffer[RX_BUFFER_SIZE];
static uint16_t rx_index = 0;
// 全局变量
static ESP8266_Status esp8266_status = ESP8266_DISCONNECTED;
static WiFi_Config wifi_config;
// 私有函数声明
static void ESP8266_USART_Init(void);
static void ESP8266_Clear_Buffer(void);
static uint8_t ESP8266_Wait_For_Response(const char *expected, uint32_t timeout);
// ESP8266初始化
void ESP8266_Init(void) {
// 初始化串口
ESP8266_USART_Init();
// 清空缓冲区
ESP8266_Clear_Buffer();
// 测试AT指令
if (ESP8266_Send_AT_Command("AT\r\n", "OK", 1000)) {
printf("ESP8266模块检测成功\r\n");
// 设置为STA模式
if (ESP8266_Send_AT_Command("AT+CWMODE=1\r\n", "OK", 1000)) {
printf("ESP8266设置为STA模式\r\n");
}
// 关闭回显
ESP8266_Send_AT_Command("ATE0\r\n", "OK", 1000);
esp8266_status = ESP8266_DISCONNECTED;
} else {
printf("ESP8266模块检测失败\r\n");
esp8266_status = ESP8266_ERROR;
}
}
// USART2初始化
static void ESP8266_USART_Init(void) {
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
// USART2配置
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(ESP8266_USART, &USART_InitStructure);
// 使能USART2
USART_Cmd(ESP8266_USART, ENABLE);
// 配置USART2中断
USART_ITConfig(ESP8266_USART, USART_IT_RXNE, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
// 清空接收缓冲区
static void ESP8266_Clear_Buffer(void) {
memset(rx_buffer, 0, RX_BUFFER_SIZE);
rx_index = 0;
}
// 获取ESP8266状态
ESP8266_Status ESP8266_Get_Status(void) {
return esp8266_status;
}
// 发送AT指令
uint8_t ESP8266_Send_AT_Command(const char *cmd, const char *expected, uint32_t timeout) {
// 清空缓冲区
ESP8266_Clear_Buffer();
// 发送命令
for (uint16_t i = 0; i < strlen(cmd); i++) {
while (USART_GetFlagStatus(ESP8266_USART, USART_FLAG_TXE) == RESET);
USART_SendData(ESP8266_USART, cmd[i]);
}
// 等待响应
return ESP8266_Wait_For_Response(expected, timeout);
}
// 等待响应
static uint8_t ESP8266_Wait_For_Response(const char *expected, uint32_t timeout) {
uint32_t start_time = 0;
uint32_t current_time = 0;
// 简化的超时等待
for (uint32_t i = 0; i < timeout * 1000; i++) {
// 检查缓冲区中是否包含期望的响应
if (strstr(rx_buffer, expected) != NULL) {
return 1;
}
// 简单的延时
for (uint32_t j = 0; j < 72; j++) {
__NOP();
}
}
return 0;
}
// 连接WiFi
uint8_t ESP8266_Connect_WiFi(const char *ssid, const char *password) {
char cmd_buffer[128];
// 保存配置
strcpy(wifi_config.ssid, ssid);
strcpy(wifi_config.password, password);
// 构建连接命令
snprintf(cmd_buffer, sizeof(cmd_buffer), "AT+CWJAP=\"%s\",\"%s\"\r\n", ssid, password);
printf("正在连接WiFi: %s\r\n", ssid);
// 发送连接命令
if (ESP8266_Send_AT_Command(cmd_buffer, "OK", 10000)) { // 10秒超时
printf("WiFi连接成功\r\n");
esp8266_status = ESP8266_CONNECTED;
return 1;
} else {
printf("WiFi连接失败\r\n");
esp8266_status = ESP8266_ERROR;
return 0;
}
}
// 连接服务器
uint8_t ESP8266_Connect_Server(const char *ip, uint16_t port) {
char cmd_buffer[128];
// 保存配置
strcpy(wifi_config.server_ip, ip);
wifi_config.server_port = port;
// 启用多连接
if (!ESP8266_Send_AT_Command("AT+CIPMUX=1\r\n", "OK", 1000)) {
return 0;
}
// 建立TCP连接
snprintf(cmd_buffer, sizeof(cmd_buffer), "AT+CIPSTART=0,\"TCP\",\"%s\",%d\r\n", ip, port);
printf("正在连接服务器: %s:%d\r\n", ip, port);
if (ESP8266_Send_AT_Command(cmd_buffer, "OK", 5000)) {
printf("服务器连接成功\r\n");
return 1;
} else {
printf("服务器连接失败\r\n");
return 0;
}
}
// 发送数据
uint8_t ESP8266_Send_Data(const char *data) {
char cmd_buffer[256];
uint16_t data_len = strlen(data);
// 检查连接状态
if (esp8266_status != ESP8266_CONNECTED) {
printf("WiFi未连接，无法发送数据\r\n");
return 0;
}
// 构建发送命令
snprintf(cmd_buffer, sizeof(cmd_buffer), "AT+CIPSEND=0,%d\r\n", data_len);
// 发送长度命令
if (!ESP8266_Send_AT_Command(cmd_buffer, ">", 1000)) {
printf("准备发送数据失败\r\n");
return 0;
}
// 发送实际数据
for (uint16_t i = 0; i < data_len; i++) {
while (USART_GetFlagStatus(ESP8266_USART, USART_FLAG_TXE) == RESET);
USART_SendData(ESP8266_USART, data[i]);
}
// 等待发送完成
if (ESP8266_Wait_For_Response("SEND OK", 2000)) {
printf("数据发送成功: %s\r\n", data);
return 1;
} else {
printf("数据发送失败\r\n");
return 0;
}
}
// 处理响应
void ESP8266_Process_Response(char *response) {
// 解析响应数据
if (strstr(response, "WIFI CONNECTED")) {
esp8266_status = ESP8266_CONNECTED;
printf("WiFi已连接\r\n");
} else if (strstr(response, "WIFI DISCONNECT")) {
esp8266_status = ESP8266_DISCONNECTED;
printf("WiFi已断开\r\n");
} else if (strstr(response, "CLOSED")) {
printf("连接已关闭\r\n");
}
// 这里可以添加更多的响应处理逻辑
}
// USART2中断服务函数
void USART2_IRQHandler(void) {
if (USART_GetITStatus(ESP8266_USART, USART_IT_RXNE) != RESET) {
uint8_t data = USART_ReceiveData(ESP8266_USART);
// 存储到接收缓冲区
if (rx_index < RX_BUFFER_SIZE - 1) {
rx_buffer[rx_index++] = data;
rx_buffer[rx_index] = '\0'; // 确保字符串结束
}
USART_ClearITPendingBit(ESP8266_USART, USART_IT_RXNE);
}
}
|
2203_75618979/Agriculture1
|
esp8266.c
|
C
|
unknown
| 6,963
|
/**
* ESP8266 WiFi模块驱动头文件
* 使用UART串口通信
*/
#ifndef __ESP8266_H
#define __ESP8266_H
#include "stm32f10x.h"
// ESP8266连接状态
typedef enum {
ESP8266_DISCONNECTED = 0,
ESP8266_CONNECTED,
ESP8266_ERROR
} ESP8266_Status;
// WiFi配置结构体
typedef struct {
char ssid[32];
char password[32];
char server_ip[16];
uint16_t server_port;
} WiFi_Config;
// 函数声明
void ESP8266_Init(void);
ESP8266_Status ESP8266_Get_Status(void);
uint8_t ESP8266_Connect_WiFi(const char *ssid, const char *password);
uint8_t ESP8266_Connect_Server(const char *ip, uint16_t port);
uint8_t ESP8266_Send_Data(const char *data);
uint8_t ESP8266_Send_AT_Command(const char *cmd, const char *expected, uint32_t timeout);
void ESP8266_Process_Response(char *response);
#endif
|
2203_75618979/Agriculture1
|
esp8266.h
|
C
|
unknown
| 818
|
/**
* MH-Z19B CO2传感器驱动
* 使用UART串口通信
*/
#include "mhz19b.h"
#include "stdio.h"
// 使用USART3连接MH-Z19B (PB10=TX, PB11=RX)
#define MHZ19B_USART USART3
#define MHZ19B_BAUDRATE 9600
// 超时定义
#define MHZ19B_TIMEOUT 1000
// 私有函数声明
static void MHZ19B_USART_Init(void);
static uint8_t MHZ19B_CalculateChecksum(uint8_t *packet, uint8_t len);
// MH-Z19B初始化
void MHZ19B_Init(void) {
GPIO_InitTypeDef GPIO_InitStructure;
// 使能GPIOB和USART3时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
// 配置USART3 TX (PB10)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// 配置USART3 RX (PB11)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// 初始化串口
MHZ19B_USART_Init();
// 延时等待传感器启动
for (int i = 0; i < 1000000; i++); // 约1秒
// 关闭自动校准
MHZ19B_Set_AutoCalibration(0);
printf("MH-Z19B CO2传感器初始化完成\r\n");
}
// USART3初始化
static void MHZ19B_USART_Init(void) {
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
// USART3配置
USART_InitStructure.USART_BaudRate = MHZ19B_BAUDRATE;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(MHZ19B_USART, &USART_InitStructure);
// 使能USART3
USART_Cmd(MHZ19B_USART, ENABLE);
// 配置USART3中断
USART_ITConfig(MHZ19B_USART, USART_IT_RXNE, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
// 计算校验和
static uint8_t MHZ19B_CalculateChecksum(uint8_t *packet, uint8_t len) {
uint8_t checksum = 0;
for (uint8_t i = 1; i < len - 1; i++) { // 从第2个字节开始，不包括校验和本身
checksum += packet[i];
}
return 0xFF - checksum;
}
// 发送命令
uint8_t MHZ19B_Send_Command(uint8_t cmd, uint8_t *data, uint8_t len) {
uint8_t packet[9];
// 构建数据包
packet[0] = 0xFF; // 起始字节1
packet[1] = 0x01; // 起始字节2 (地址)
packet[2] = cmd; // 命令
// 填充数据
for (uint8_t i = 0; i < 5; i++) {
if (i < len) {
packet[3 + i] = data[i];
} else {
packet[3 + i] = 0x00;
}
}
// 计算校验和
packet[8] = MHZ19B_CalculateChecksum(packet, 9);
// 发送数据包
for (uint8_t i = 0; i < 9; i++) {
while (USART_GetFlagStatus(MHZ19B_USART, USART_FLAG_TXE) == RESET);
USART_SendData(MHZ19B_USART, packet[i]);
}
return 1;
}
// 接收响应
uint8_t MHZ19B_Receive_Response(MHZ19B_Packet *packet) {
uint8_t buffer[9];
uint32_t timeout = MHZ19B_TIMEOUT;
// 等待接收9个字节
for (uint8_t i = 0; i < 9; i++) {
while (USART_GetFlagStatus(MHZ19B_USART, USART_FLAG_RXNE) == RESET) {
if (--timeout == 0) {
return 0; // 超时
}
}
buffer[i] = USART_ReceiveData(MHZ19B_USART);
}
// 验证起始字节
if (buffer[0] != 0xFF || buffer[1] != 0x01) {
return 0;
}
// 验证校验和
uint8_t checksum = MHZ19B_CalculateChecksum(buffer, 9);
if (buffer[8] != checksum) {
return 0;
}
// 复制数据到结构体
packet->header[0] = buffer[0];
packet->header[1] = buffer[1];
packet->cmd = buffer[2];
for (uint8_t i = 0; i < 5; i++) {
packet->data[i] = buffer[3 + i];
}
packet->checksum = buffer[8];
return 1;
}
// 读取CO2浓度
uint16_t MHZ19B_Read_CO2(void) {
MHZ19B_Packet response;
uint8_t cmd_data[5] = {0};
// 发送读取CO2命令
if (!MHZ19B_Send_Command(MHZ19B_CMD_READ_CO2, cmd_data, 0)) {
return 0;
}
// 等待响应
for (int i = 0; i < 10000; i++); // 短暂延时
// 接收响应
if (!MHZ19B_Receive_Response(&response)) {
return 0;
}
// 解析CO2浓度 (高字节在前)
uint16_t co2_ppm = (response.data[0] << 8) | response.data[1];
printf("CO2浓度: %d ppm\r\n", co2_ppm);
return co2_ppm;
}
// 读取温度
uint8_t MHZ19B_Read_Temperature(void) {
MHZ19B_Packet response;
uint8_t cmd_data[5] = {0};
// 发送读取温度命令
if (!MHZ19B_Send_Command(MHZ19B_CMD_READ_TEMP, cmd_data, 0)) {
return 0;
}
// 等待响应
for (int i = 0; i < 10000; i++); // 短暂延时
// 接收响应
if (!MHZ19B_Receive_Response(&response)) {
return 0;
}
// 解析温度值
uint8_t temp = response.data[0] - 40; // 温度补偿
printf("温度: %d C\r\n", temp);
return temp;
}
// 设置自动校准
uint8_t MHZ19B_Set_AutoCalibration(uint8_t enable) {
MHZ19B_Packet response;
uint8_t cmd_data[5] = {0};
if (enable) {
cmd_data[0] = 0xA0; // 开启自动校准
} else {
cmd_data[0] = 0x00; // 关闭自动校准
}
// 发送命令
if (!MHZ19B_Send_Command(MHZ19B_CMD_AUTO_CALIBRATION, cmd_data, 1)) {
return 0;
}
// 等待响应
for (int i = 0; i < 10000; i++); // 短暂延时
// 接收响应
if (!MHZ19B_Receive_Response(&response)) {
return 0;
}
printf("自动校准%s\r\n", enable ? "开启" : "关闭");
return 1;
}
// 零点校准
uint8_t MHZ19B_Calibrate_Zero(void) {
MHZ19B_Packet response;
uint8_t cmd_data[5] = {0};
// 发送零点校准命令
if (!MHZ19B_Send_Command(MHZ19B_CMD_CALIBRATE_ZERO, cmd_data, 0)) {
return 0;
}
// 等待响应
for (int i = 0; i < 10000; i++); // 短暂延时
// 接收响应
if (!MHZ19B_Receive_Response(&response)) {
return 0;
}
printf("零点校准完成\r\n");
return 1;
}
// USART3中断服务函数
void USART3_IRQHandler(void) {
if (USART_GetITStatus(MHZ19B_USART, USART_IT_RXNE) != RESET) {
// 接收中断处理 (如果需要的话)
uint8_t data = USART_ReceiveData(MHZ19B_USART);
// 这里可以添加接收缓冲区管理
USART_ClearITPendingBit(MHZ19B_USART, USART_IT_RXNE);
}
}
|
2203_75618979/Agriculture1
|
mhz19b.c
|
C
|
unknown
| 6,992
|
/**
* MH-Z19B CO2传感器驱动头文件
* 使用UART串口通信
*/
#ifndef __MHZ19B_H
#define __MHZ19B_H
#include "stm32f10x.h"
// MH-Z19B命令定义
#define MHZ19B_CMD_READ_CO2 0x86
#define MHZ19B_CMD_CALIBRATE_ZERO 0x87
#define MHZ19B_CMD_CALIBRATE_SPAN 0x88
#define MHZ19B_CMD_AUTO_CALIBRATION 0x79
#define MHZ19B_CMD_DETECTION_RANGE 0x99
#define MHZ19B_CMD_READ_TEMP 0x85
// 数据包结构
typedef struct {
uint8_t header[2]; // 起始字节: 0xFF, 0x01
uint8_t cmd; // 命令
uint8_t data[5]; // 数据
uint8_t checksum; // 校验和
} MHZ19B_Packet;
// 函数声明
void MHZ19B_Init(void);
uint16_t MHZ19B_Read_CO2(void);
uint8_t MHZ19B_Read_Temperature(void);
uint8_t MHZ19B_Set_AutoCalibration(uint8_t enable);
uint8_t MHZ19B_Calibrate_Zero(void);
uint8_t MHZ19B_Send_Command(uint8_t cmd, uint8_t *data, uint8_t len);
uint8_t MHZ19B_Receive_Response(MHZ19B_Packet *packet);
#endif
|
2203_75618979/Agriculture1
|
mhz19b.h
|
C
|
unknown
| 952
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
智能农业大棚监控系统 - Flask后端服务器
接收STM32上传的传感器数据，提供Web管理界面
"""
from flask import Flask, render_template, jsonify, request
from flask_cors import CORS
import json
import time
import threading
from datetime import datetime
import logging
# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
app = Flask(__name__)
CORS(app) # 允许跨域访问
# 全局数据存储
greenhouse_data = {
'nodes': {}, # 存储所有节点数据
'system_status': {
'total_nodes': 0,
'online_nodes': 0,
'last_update': None
}
}
# 作物模板配置
crop_templates = {
'tomato': {
'name': '番茄',
'soil_temp_min': 18,
'soil_temp_max': 28,
'soil_humidity_min': 60,
'soil_humidity_max': 80,
'co2_min': 400,
'co2_max': 1000,
'light_min': 20000,
'light_max': 50000
},
'strawberry': {
'name': '草莓',
'soil_temp_min': 15,
'soil_temp_max': 25,
'soil_humidity_min': 70,
'soil_humidity_max': 90,
'co2_min': 350,
'co2_max': 800,
'light_min': 15000,
'light_max': 40000
},
'general': {
'name': '通用',
'soil_temp_min': 16,
'soil_temp_max': 30,
'soil_humidity_min': 50,
'soil_humidity_max': 85,
'co2_min': 300,
'co2_max': 1200,
'light_min': 10000,
'light_max': 60000
}
}
# 节点超时时间 (秒)
NODE_TIMEOUT = 30
def check_node_status():
"""检查节点在线状态"""
current_time = time.time()
online_count = 0
for node_id, node_data in greenhouse_data['nodes'].items():
last_update = node_data.get('timestamp', 0)
if current_time - last_update < NODE_TIMEOUT:
node_data['status'] = 'online'
online_count += 1
else:
node_data['status'] = 'offline'
greenhouse_data['system_status']['online_nodes'] = online_count
greenhouse_data['system_status']['last_update'] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
@app.route('/')
def index():
"""主页"""
return render_template('index.html')
@app.route('/api/data', methods=['POST'])
def receive_data():
"""接收STM32上传的传感器数据"""
try:
data = request.get_json()
if not data or 'node_id' not in data:
return jsonify({'error': 'Invalid data format'}), 400
node_id = str(data['node_id'])
# 验证数据完整性
required_fields = ['soil_temp', 'soil_humidity', 'co2', 'light', 'pump_status', 'heater_status']
for field in required_fields:
if field not in data:
return jsonify({'error': f'Missing field: {field}'}), 400
# 处理数据
node_data = {
'node_id': node_id,
'soil_temp': float(data['soil_temp']),
'soil_humidity': float(data['soil_humidity']),
'co2': int(data['co2']),
'light': int(data['light']),
'pump_status': int(data['pump_status']),
'heater_status': int(data['heater_status']),
'timestamp': time.time(),
'status': 'online'
}
# 存储数据
greenhouse_data['nodes'][node_id] = node_data
# 更新系统状态
greenhouse_data['system_status']['total_nodes'] = len(greenhouse_data['nodes'])
logger.info(f"收到节点 {node_id} 数据: 温度={node_data['soil_temp']}°C, 湿度={node_data['soil_humidity']}%, CO2={node_data['co2']}ppm, 光照={node_data['light']}lux")
return jsonify({'status': 'success', 'message': 'Data received successfully'})
except Exception as e:
logger.error(f"接收数据错误: {str(e)}")
return jsonify({'error': str(e)}), 500
@app.route('/api/data', methods=['GET'])
def get_data():
"""获取所有节点数据"""
check_node_status()
return jsonify(greenhouse_data)
@app.route('/api/nodes/<node_id>', methods=['GET'])
def get_node_data(node_id):
"""获取指定节点数据"""
check_node_status()
if node_id not in greenhouse_data['nodes']:
return jsonify({'error': 'Node not found'}), 404
return jsonify(greenhouse_data['nodes'][node_id])
@app.route('/api/control/<node_id>', methods=['POST'])
def control_device(node_id):
"""控制设备开关"""
try:
data = request.get_json()
if not data:
return jsonify({'error': 'No control data provided'}), 400
# 验证节点是否存在
if node_id not in greenhouse_data['nodes']:
return jsonify({'error': 'Node not found'}), 404
# 构建控制命令
control_cmd = {
'node_id': node_id,
'command': 'manual_control'
}
if 'pump_status' in data:
control_cmd['pump_status'] = int(data['pump_status'])
if 'heater_status' in data:
control_cmd['heater_status'] = int(data['heater_status'])
# 这里应该将命令发送回STM32
# 由于STM32是客户端，我们需要等待下次数据上传时携带命令
# 简化处理：直接存储控制状态
if 'pump_status' in control_cmd:
greenhouse_data['nodes'][node_id]['manual_pump'] = control_cmd['pump_status']
if 'heater_status' in control_cmd:
greenhouse_data['nodes'][node_id]['manual_heater'] = control_cmd['heater_status']
logger.info(f"节点 {node_id} 控制命令: {control_cmd}")
return jsonify({'status': 'success', 'command': control_cmd})
except Exception as e:
logger.error(f"控制设备错误: {str(e)}")
return jsonify({'error': str(e)}), 500
@app.route('/api/templates', methods=['GET'])
def get_templates():
"""获取作物模板"""
return jsonify(crop_templates)
@app.route('/api/templates/<template_name>', methods=['POST'])
def apply_template(template_name):
"""应用作物模板"""
try:
if template_name not in crop_templates:
return jsonify({'error': 'Template not found'}), 404
data = request.get_json()
node_id = str(data.get('node_id', '1'))
template = crop_templates[template_name]
# 构建模板应用命令
template_cmd = {
'node_id': node_id,
'command': 'apply_template',
'template': template_name,
'thresholds': {
'soil_temp_min': template['soil_temp_min'],
'soil_temp_max': template['soil_temp_max'],
'soil_humidity_min': template['soil_humidity_min'],
'soil_humidity_max': template['soil_humidity_max'],
'co2_min': template['co2_min'],
'co2_max': template['co2_max'],
'light_min': template['light_min'],
'light_max': template['light_max']
}
}
logger.info(f"节点 {node_id} 应用模板: {template['name']}")
return jsonify({'status': 'success', 'template': template, 'command': template_cmd})
except Exception as e:
logger.error(f"应用模板错误: {str(e)}")
return jsonify({'error': str(e)}), 500
@app.route('/api/alarm/<node_id>', methods=['POST'])
def handle_alarm(node_id):
"""处理报警"""
try:
data = request.get_json()
alarm_type = data.get('type', 'unknown')
message = data.get('message', '')
logger.warning(f"节点 {node_id} 报警: {alarm_type} - {message}")
# 这里可以添加邮件、短信等通知功能
# 简化处理：只记录日志
return jsonify({'status': 'success', 'message': 'Alarm handled'})
except Exception as e:
logger.error(f"处理报警错误: {str(e)}")
return jsonify({'error': str(e)}), 500
def background_task():
"""后台任务：清理过期数据"""
while True:
try:
current_time = time.time()
# 清理过期节点数据
expired_nodes = []
for node_id, node_data in greenhouse_data['nodes'].items():
if current_time - node_data.get('timestamp', 0) > NODE_TIMEOUT * 2:
expired_nodes.append(node_id)
for node_id in expired_nodes:
del greenhouse_data['nodes'][node_id]
logger.info(f"清理过期节点: {node_id}")
# 更新系统状态
greenhouse_data['system_status']['total_nodes'] = len(greenhouse_data['nodes'])
time.sleep(60) # 每分钟检查一次
except Exception as e:
logger.error(f"后台任务错误: {str(e)}")
time.sleep(60)
if __name__ == '__main__':
# 启动后台任务
bg_thread = threading.Thread(target=background_task, daemon=True)
bg_thread.start()
logger.info("智能农业大棚监控系统服务器启动")
logger.info("访问地址: http://localhost:5000")
# 启动Flask应用
app.run(host='0.0.0.0', port=5000, debug=True, threaded=True)
|
2203_75618979/Agriculture1
|
server.py
|
Python
|
unknown
| 9,541
|
/**
* SHT30温湿度传感器驱动
* 使用I2C接口通信
*/
#include "sht30.h"
#include "stdio.h"
// I2C超时定义
#define I2C_TIMEOUT 10000
// 延时函数
static void Delay_us(uint32_t us) {
uint32_t count = us * 8; // 72MHz时钟
while (count--) {
__NOP();
}
}
// 等待I2C事件
static uint8_t I2C_WaitEvent(I2C_TypeDef* I2Cx, uint32_t event) {
uint32_t timeout = I2C_TIMEOUT;
while (!I2C_CheckEvent(I2Cx, event)) {
if (--timeout == 0) return 0;
}
return 1;
}
// SHT30初始化
void SHT30_Init(void) {
// 发送软复位命令
SHT30_SoftReset();
// 延时等待传感器初始化
Delay_us(2000);
printf("SHT30温湿度传感器初始化完成\r\n");
}
// SHT30软复位
uint8_t SHT30_SoftReset(void) {
uint8_t cmd_high = (SHT30_CMD_SOFTRESET >> 8) & 0xFF;
uint8_t cmd_low = SHT30_CMD_SOFTRESET & 0xFF;
// 发送起始信号
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
// 发送设备地址
I2C_Send7bitAddress(I2C1, SHT30_I2C_ADDR, I2C_Direction_Transmitter);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) return 0;
// 发送命令高字节
I2C_SendData(I2C1, cmd_high);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return 0;
// 发送命令低字节
I2C_SendData(I2C1, cmd_low);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return 0;
// 发送停止信号
I2C_GenerateSTOP(I2C1, ENABLE);
return 1;
}
// 读取温湿度数据
uint8_t SHT30_Read(float *temperature, float *humidity) {
uint8_t tx_data[2];
uint8_t rx_data[6];
uint16_t temp_raw, humi_raw;
// 发送测量命令 (高精度，时钟拉伸禁用)
tx_data[0] = (SHT30_CMD_MEAS_CLOCKSTR_H >> 8) & 0xFF;
tx_data[1] = SHT30_CMD_MEAS_CLOCKSTR_H & 0xFF;
// 发送起始信号
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
// 发送设备地址
I2C_Send7bitAddress(I2C1, SHT30_I2C_ADDR, I2C_Direction_Transmitter);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) return 0;
// 发送命令
I2C_SendData(I2C1, tx_data[0]);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return 0;
I2C_SendData(I2C1, tx_data[1]);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return 0;
// 发送停止信号
I2C_GenerateSTOP(I2C1, ENABLE);
// 等待测量完成 (15ms)
Delay_us(15000);
// 读取数据
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
I2C_Send7bitAddress(I2C1, SHT30_I2C_ADDR, I2C_Direction_Receiver);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) return 0;
// 读取6个字节数据
for (int i = 0; i < 6; i++) {
if (i == 5) {
// 最后一个字节不发送ACK
I2C_AcknowledgeConfig(I2C1, DISABLE);
}
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)) return 0;
rx_data[i] = I2C_ReceiveData(I2C1);
}
// 发送停止信号
I2C_GenerateSTOP(I2C1, ENABLE);
// 重新使能ACK
I2C_AcknowledgeConfig(I2C1, ENABLE);
// CRC校验
if (!SHT30_CheckCrc(&rx_data[0], 2, rx_data[2])) return 0;
if (!SHT30_CheckCrc(&rx_data[3], 2, rx_data[5])) return 0;
// 解析数据
temp_raw = (rx_data[0] << 8) | rx_data[1];
humi_raw = (rx_data[3] << 8) | rx_data[4];
// 计算温湿度值
*temperature = -45.0 + 175.0 * temp_raw / 65535.0;
*humidity = 100.0 * humi_raw / 65535.0;
return 1;
}
// CRC8校验
uint8_t SHT30_CheckCrc(uint8_t data[], uint8_t nbrOfBytes, uint8_t checksum) {
uint8_t crc = 0xFF;
uint8_t bit = 0;
uint8_t byteCtr;
// 计算CRC
for (byteCtr = 0; byteCtr < nbrOfBytes; ++byteCtr) {
crc ^= (data[byteCtr]);
for (bit = 8; bit > 0; --bit) {
if (crc & 0x80) {
crc = (crc << 1) ^ 0x31;
} else {
crc = (crc << 1);
}
}
}
return (crc == checksum);
}
// 读取状态寄存器
uint8_t SHT30_ReadStatus(uint16_t *status) {
uint8_t cmd_high = (SHT30_CMD_READSTATUS >> 8) & 0xFF;
uint8_t cmd_low = SHT30_CMD_READSTATUS & 0xFF;
uint8_t rx_data[3];
// 发送读取状态命令
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
I2C_Send7bitAddress(I2C1, SHT30_I2C_ADDR, I2C_Direction_Transmitter);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) return 0;
I2C_SendData(I2C1, cmd_high);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return 0;
I2C_SendData(I2C1, cmd_low);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return 0;
// 重新启动读取数据
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return 0;
I2C_Send7bitAddress(I2C1, SHT30_I2C_ADDR, I2C_Direction_Receiver);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) return 0;
// 读取3个字节
for (int i = 0; i < 3; i++) {
if (i == 2) {
I2C_AcknowledgeConfig(I2C1, DISABLE);
}
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)) return 0;
rx_data[i] = I2C_ReceiveData(I2C1);
}
I2C_GenerateSTOP(I2C1, ENABLE);
I2C_AcknowledgeConfig(I2C1, ENABLE);
// CRC校验
if (!SHT30_CheckCrc(&rx_data[0], 2, rx_data[2])) return 0;
*status = (rx_data[0] << 8) | rx_data[1];
return 1;
}
|
2203_75618979/Agriculture1
|
sht30.c
|
C
|
unknown
| 5,854
|
/**
* SHT30温湿度传感器驱动头文件
* 使用I2C接口通信
*/
#ifndef __SHT30_H
#define __SHT30_H
#include "stm32f10x.h"
// SHT30 I2C地址
#define SHT30_I2C_ADDR 0x44 // 7位地址
#define SHT30_I2C_ADDR_WRITE (SHT30_I2C_ADDR << 1)
#define SHT30_I2C_ADDR_READ ((SHT30_I2C_ADDR << 1) | 0x01)
// SHT30命令
#define SHT30_CMD_READSTATUS 0xF32D
#define SHT30_CMD_CLEARSTATUS 0x3041
#define SHT30_CMD_SOFTRESET 0x30A2
#define SHT30_CMD_HEATER_ENABLE 0x306D
#define SHT30_CMD_HEATER_DISABLE 0x3066
#define SHT30_CMD_READOUT 0xE000
// 测量命令 (单次测量，时钟拉伸禁用，高精度)
#define SHT30_CMD_MEAS_CLOCKSTR_H 0x2C06
#define SHT30_CMD_MEAS_CLOCKSTR_M 0x2C0D
#define SHT30_CMD_MEAS_CLOCKSTR_L 0x2C10
// 函数声明
void SHT30_Init(void);
uint8_t SHT30_Read(float *temperature, float *humidity);
uint8_t SHT30_SoftReset(void);
uint8_t SHT30_ReadStatus(uint16_t *status);
uint8_t SHT30_CheckCrc(uint8_t data[], uint8_t nbrOfBytes, uint8_t checksum);
#endif
|
2203_75618979/Agriculture1
|
sht30.h
|
C
|
unknown
| 1,025
|
/**
* SSD1306 OLED显示屏驱动
* 0.96寸 128x64分辨率 I2C接口
*/
#include "ssd1306.h"
#include "stdio.h"
#include "string.h"
// OLED显存
static uint8_t SSD1306_Buffer[SSD1306_WIDTH * SSD1306_HEIGHT / 8];
// 当前光标位置
static uint8_t SSD1306_CursorX = 0;
static uint8_t SSD1306_CursorY = 0;
// I2C超时定义
#define I2C_TIMEOUT 10000
// 延时函数
static void Delay_us(uint32_t us) {
uint32_t count = us * 8; // 72MHz时钟
while (count--) {
__NOP();
}
}
// 等待I2C事件
static uint8_t I2C_WaitEvent(I2C_TypeDef* I2Cx, uint32_t event) {
uint32_t timeout = I2C_TIMEOUT;
while (!I2C_CheckEvent(I2Cx, event)) {
if (--timeout == 0) return 0;
}
return 1;
}
// 发送命令
static void SSD1306_WriteCommand(uint8_t command) {
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return;
I2C_Send7bitAddress(I2C1, SSD1306_I2C_ADDR >> 1, I2C_Direction_Transmitter);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) return;
// 发送命令标志
I2C_SendData(I2C1, SSD1306_CMD);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return;
// 发送命令
I2C_SendData(I2C1, command);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return;
I2C_GenerateSTOP(I2C1, ENABLE);
}
// 发送数据
static void SSD1306_WriteData(uint8_t data) {
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return;
I2C_Send7bitAddress(I2C1, SSD1306_I2C_ADDR >> 1, I2C_Direction_Transmitter);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) return;
// 发送数据标志
I2C_SendData(I2C1, SSD1306_DATA);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return;
// 发送数据
I2C_SendData(I2C1, data);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return;
I2C_GenerateSTOP(I2C1, ENABLE);
}
// SSD1306初始化
void SSD1306_Init(void) {
// 基本初始化序列
SSD1306_WriteCommand(0xAE); // 关闭显示
SSD1306_WriteCommand(0x20); // 设置内存地址模式
SSD1306_WriteCommand(0x10); // 00:水平寻址模式; 01:垂直寻址模式; 10:页寻址模式(默认)
SSD1306_WriteCommand(0xB0); // 设置页起始地址 (页寻址模式)
SSD1306_WriteCommand(0xC8); // 设置COM输出扫描方向 (C0:正常; C8:反向)
SSD1306_WriteCommand(0x00); // 设置低列地址
SSD1306_WriteCommand(0x10); // 设置高列地址
SSD1306_WriteCommand(0x40); // 设置显示起始行 (0x40-0x7F)
SSD1306_WriteCommand(0x81); // 设置对比度控制
SSD1306_WriteCommand(0xFF); // 对比度值 (0x00-0xFF)
SSD1306_WriteCommand(0xA1); // 设置段重映射 (A0:正常; A1:反向)
SSD1306_WriteCommand(0xA6); // 设置正常/反向显示 (A6:正常; A7:反向)
SSD1306_WriteCommand(0xA8); // 设置多路复用比
SSD1306_WriteCommand(0x3F); // 1/64 duty (0x0F-0x3F)
SSD1306_WriteCommand(0xA4); // 输出跟随RAM内容
SSD1306_WriteCommand(0xD3); // 设置显示偏移
SSD1306_WriteCommand(0x00); // 无偏移
SSD1306_WriteCommand(0xD5); // 设置显示时钟分频比/振荡器频率
SSD1306_WriteCommand(0xF0); // 分频比=1, 振荡器频率最高
SSD1306_WriteCommand(0xD9); // 设置预充电周期
SSD1306_WriteCommand(0x22); // Phase1=2 DCLK, Phase2=2 DCLK
SSD1306_WriteCommand(0xDA); // 设置COM引脚硬件配置
SSD1306_WriteCommand(0x12); // 替代COM引脚配置
SSD1306_WriteCommand(0xDB); // 设置VCOMH取消选择级别
SSD1306_WriteCommand(0x20); // 0x20: 0.77xVCC
SSD1306_WriteCommand(0x8D); // 设置电荷泵
SSD1306_WriteCommand(0x14); // 使能电荷泵
SSD1306_WriteCommand(0xAF); // 开启显示
// 清空屏幕
SSD1306_Clear();
SSD1306_UpdateScreen();
printf("SSD1306 OLED显示屏初始化完成\r\n");
}
// 清空屏幕
void SSD1306_Clear(void) {
memset(SSD1306_Buffer, 0x00, sizeof(SSD1306_Buffer));
SSD1306_CursorX = 0;
SSD1306_CursorY = 0;
}
// 更新显示
void SSD1306_UpdateScreen(void) {
uint8_t i, j;
for (i = 0; i < 8; i++) {
SSD1306_WriteCommand(0xB0 + i); // 设置页地址 (0-7)
SSD1306_WriteCommand(0x00); // 设置低列地址
SSD1306_WriteCommand(0x10); // 设置高列地址
// 发送数据
I2C_GenerateSTART(I2C1, ENABLE);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) return;
I2C_Send7bitAddress(I2C1, SSD1306_I2C_ADDR >> 1, I2C_Direction_Transmitter);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) return;
I2C_SendData(I2C1, SSD1306_DATA);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return;
for (j = 0; j < 128; j++) {
I2C_SendData(I2C1, SSD1306_Buffer[j + (i * 128)]);
if (!I2C_WaitEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) return;
}
I2C_GenerateSTOP(I2C1, ENABLE);
}
}
// 设置光标位置
void SSD1306_SetCursor(uint8_t x, uint8_t y) {
SSD1306_CursorX = x;
SSD1306_CursorY = y;
}
// 绘制像素点
void SSD1306_DrawPixel(uint8_t x, uint8_t y, uint8_t color) {
if (x >= SSD1306_WIDTH || y >= SSD1306_HEIGHT) {
return;
}
if (color) {
SSD1306_Buffer[x + (y / 8) * SSD1306_WIDTH] |= (1 << (y % 8));
} else {
SSD1306_Buffer[x + (y / 8) * SSD1306_WIDTH] &= ~(1 << (y % 8));
}
}
// 绘制线条
void SSD1306_DrawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t color) {
int dx = abs(x2 - x1);
int dy = abs(y2 - y1);
int sx = (x1 < x2) ? 1 : -1;
int sy = (y1 < y2) ? 1 : -1;
int err = dx - dy;
while (1) {
SSD1306_DrawPixel(x1, y1, color);
if (x1 == x2 && y1 == y2) break;
int e2 = 2 * err;
if (e2 > -dy) {
err -= dy;
x1 += sx;
}
if (e2 < dx) {
err += dx;
y1 += sy;
}
}
}
// 绘制矩形
void SSD1306_DrawRectangle(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t color) {
SSD1306_DrawLine(x, y, x + w, y, color); // 上边
SSD1306_DrawLine(x, y + h, x + w, y + h, color); // 下边
SSD1306_DrawLine(x, y, x, y + h, color); // 左边
SSD1306_DrawLine(x + w, y, x + w, y + h, color); // 右边
}
// 绘制位图
void SSD1306_DrawBitmap(uint8_t x, uint8_t y, const uint8_t *bitmap, uint8_t w, uint8_t h) {
int8_t byteWidth = (w + 7) / 8;
uint8_t byte = 0;
for (uint8_t j = 0; j < h; j++, y++) {
for (uint8_t i = 0; i < w; i++) {
if (i & 7) byte >>= 1;
else byte = bitmap[j * byteWidth + i / 8];
SSD1306_DrawPixel(x + i, y, byte & 0x01);
}
}
}
// 6x8字体数据 (简化版，只包含ASCII字符)
static const uint8_t Font6x8[][6] = {
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // 空格
{0x00, 0x00, 0x5F, 0x00, 0x00, 0x00}, // !
{0x00, 0x07, 0x00, 0x07, 0x00, 0x00}, // "
// ... 这里应该包含完整的ASCII字符集
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // ~
};
// 写入字符
void SSD1306_WriteChar(char ch, FontDef font) {
uint32_t i, b, j;
// 检查边界
if (SSD1306_WIDTH <= (SSD1306_CursorX + 6) || SSD1306_HEIGHT <= (SSD1306_CursorY + 8)) {
return;
}
// 根据字体选择字符数据 (这里简化处理)
if (ch >= 32 && ch <= 126) { // ASCII字符范围
for (i = 0; i < 6; i++) {
uint8_t line = Font6x8[ch - 32][i];
for (j = 0; j < 8; j++) {
if (line & (1 << j)) {
SSD1306_DrawPixel(SSD1306_CursorX + i, SSD1306_CursorY + j, 1);
} else {
SSD1306_DrawPixel(SSD1306_CursorX + i, SSD1306_CursorY + j, 0);
}
}
}
}
// 更新光标位置
SSD1306_CursorX += 6;
}
// 写入字符串
void SSD1306_WriteString(char *str, FontDef font) {
while (*str) {
if (*str == '\n') {
SSD1306_CursorY += 8;
SSD1306_CursorX = 0;
} else if (*str == '\r') {
SSD1306_CursorX = 0;
} else {
SSD1306_WriteChar(*str, font);
}
str++;
}
}
|
2203_75618979/Agriculture1
|
ssd1306.c
|
C
|
unknown
| 8,565
|
/**
* SSD1306 OLED显示屏驱动头文件
* 0.96寸 128x64分辨率 I2C接口
*/
#ifndef __SSD1306_H
#define __SSD1306_H
#include "stm32f10x.h"
// OLED尺寸定义
#define SSD1306_WIDTH 128
#define SSD1306_HEIGHT 64
// SSD1306 I2C地址
#define SSD1306_I2C_ADDR 0x78 // 7位地址: 0x3C, 左移1位
// SSD1306命令定义
#define SSD1306_CMD 0x00
#define SSD1306_DATA 0x40
// 基本命令
#define SSD1306_SET_CONTRAST 0x81
#define SSD1306_DISPLAY_ALL_ON 0xA4
#define SSD1306_DISPLAY_ALL_OFF 0xA5
#define SSD1306_DISPLAY_NORMAL 0xA6
#define SSD1306_DISPLAY_INVERSE 0xA7
#define SSD1306_DISPLAY_OFF 0xAE
#define SSD1306_DISPLAY_ON 0xAF
// 滚动命令
#define SSD1306_SCROLL_RIGHT 0x26
#define SSD1306_SCROLL_LEFT 0x27
#define SSD1306_SCROLL_OFF 0x2E
// 字体大小定义
typedef enum {
Font_6x8,
Font_7x10,
Font_11x18,
Font_16x26
} FontDef;
// 字体结构体
typedef struct {
const uint8_t *data;
uint8_t width;
uint8_t height;
uint8_t bytes;
} Font;
// 函数声明
void SSD1306_Init(void);
void SSD1306_Clear(void);
void SSD1306_UpdateScreen(void);
void SSD1306_SetCursor(uint8_t x, uint8_t y);
void SSD1306_WriteChar(char ch, FontDef font);
void SSD1306_WriteString(char *str, FontDef font);
void SSD1306_DrawPixel(uint8_t x, uint8_t y, uint8_t color);
void SSD1306_DrawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t color);
void SSD1306_DrawRectangle(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t color);
void SSD1306_DrawBitmap(uint8_t x, uint8_t y, const uint8_t *bitmap, uint8_t w, uint8_t h);
// 字体声明
extern Font Font_6x8_data;
extern Font Font_7x10_data;
extern Font Font_11x18_data;
extern Font Font_16x26_data;
#endif
|
2203_75618979/Agriculture1
|
ssd1306.h
|
C
|
unknown
| 1,782
|
/**
* STM32F103 智能农业大棚监控系统
* 功能：传感器数据采集、自动控制、WiFi通信
* 作者：Inscode AI
* 日期：2025-12-03
*/
#include "stm32f10x.h"
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
// 传感器驱动头文件
#include "sht30.h"
#include "mhz19b.h"
#include "bh1750.h"
#include "ssd1306.h"
#include "esp8266.h"
// 系统配置
#define NODE_ID 1 // 大棚节点ID (1-8)
#define DATA_UPLOAD_INTERVAL 30000 // 数据上传间隔 30秒
#define CONTROL_INTERVAL 10000 // 控制周期 10秒
// 作物模板配置
typedef struct {
char name[16]; // 作物名称
float soil_temp_min; // 土壤温度最小值
float soil_temp_max; // 土壤温度最大值
float soil_humidity_min; // 土壤湿度最小值
float soil_humidity_max; // 土壤湿度最大值
float co2_min; // CO2最小值
float co2_max; // CO2最大值
float light_min; // 光照最小值 (lux)
float light_max; // 光照最大值 (lux)
} CropTemplate;
// 传感器数据结构
typedef struct {
float soil_temperature; // 土壤温度 (°C)
float soil_humidity; // 土壤湿度 (%)
float air_co2; // 空气CO2浓度 (ppm)
float light_intensity; // 光照强度 (lux)
uint32_t timestamp; // 时间戳
} SensorData;
// 系统状态
typedef struct {
uint8_t pump_status; // 水泵状态 (0:关闭, 1:开启)
uint8_t heater_status; // 加热灯状态 (0:关闭, 1:开启)
uint8_t wifi_connected; // WiFi连接状态
uint8_t auto_mode; // 自动模式 (0:手动, 1:自动)
uint8_t current_crop; // 当前作物模板索引
} SystemStatus;
// 全局变量
SensorData g_sensor_data;
SystemStatus g_system_status;
CropTemplate g_crop_templates[3];
uint32_t g_last_upload_time = 0;
uint32_t g_last_control_time = 0;
// 函数声明
void System_Init(void);
void GPIO_Init_Config(void);
void Timer_Init_Config(void);
void USART_Init_Config(void);
void I2C_Init_Config(void);
void ADC_Init_Config(void);
void Sensor_Read_All(void);
void Control_Execute(void);
void Data_Upload(void);
void OLED_Display_Data(void);
void Alarm_Check(void);
void Delay_ms(uint32_t ms);
void Delay_us(uint32_t us);
// 作物模板初始化
void Crop_Templates_Init(void) {
// 番茄模板
strcpy(g_crop_templates[0].name, "番茄");
g_crop_templates[0].soil_temp_min = 18.0;
g_crop_templates[0].soil_temp_max = 25.0;
g_crop_templates[0].soil_humidity_min = 40.0;
g_crop_templates[0].soil_humidity_max = 60.0;
g_crop_templates[0].co2_min = 800.0;
g_crop_templates[0].co2_max = 1200.0;
g_crop_templates[0].light_min = 20000.0;
g_crop_templates[0].light_max = 50000.0;
// 草莓模板
strcpy(g_crop_templates[1].name, "草莓");
g_crop_templates[1].soil_temp_min = 15.0;
g_crop_templates[1].soil_temp_max = 20.0;
g_crop_templates[1].soil_humidity_min = 50.0;
g_crop_templates[1].soil_humidity_max = 70.0;
g_crop_templates[1].co2_min = 600.0;
g_crop_templates[1].co2_max = 1000.0;
g_crop_templates[1].light_min = 15000.0;
g_crop_templates[1].light_max = 40000.0;
// 通用模板
strcpy(g_crop_templates[2].name, "通用");
g_crop_templates[2].soil_temp_min = 16.0;
g_crop_templates[2].soil_temp_max = 24.0;
g_crop_templates[2].soil_humidity_min = 45.0;
g_crop_templates[2].soil_humidity_max = 65.0;
g_crop_templates[2].co2_min = 700.0;
g_crop_templates[2].co2_max = 1100.0;
g_crop_templates[2].light_min = 18000.0;
g_crop_templates[2].light_max = 45000.0;
}
// 主函数
int main(void) {
System_Init();
printf("STM32 智能农业大棚监控系统启动...\r\n");
printf("节点ID: %d\r\n", NODE_ID);
// 初始化作物模板
Crop_Templates_Init();
g_system_status.current_crop = 0; // 默认番茄
g_system_status.auto_mode = 1; // 默认自动模式
// 初始化传感器
SHT30_Init();
MHZ19B_Init();
BH1750_Init();
SSD1306_Init();
ESP8266_Init();
printf("系统初始化完成\r\n");
while (1) {
uint32_t current_time = millis();
// 读取传感器数据
Sensor_Read_All();
// OLED显示
OLED_Display_Data();
// 自动控制
if (g_system_status.auto_mode &&
(current_time - g_last_control_time >= CONTROL_INTERVAL)) {
Control_Execute();
g_last_control_time = current_time;
}
// 数据上传
if (current_time - g_last_upload_time >= DATA_UPLOAD_INTERVAL) {
Data_Upload();
g_last_upload_time = current_time;
}
// 报警检查
Alarm_Check();
Delay_ms(100);
}
}
// 系统初始化
void System_Init(void) {
// 初始化系统时钟
SystemCoreClockUpdate();
// 初始化各个模块
GPIO_Init_Config();
Timer_Init_Config();
USART_Init_Config();
I2C_Init_Config();
ADC_Init_Config();
// 初始化全局变量
memset(&g_sensor_data, 0, sizeof(SensorData));
memset(&g_system_status, 0, sizeof(SystemStatus));
}
// GPIO初始化配置
void GPIO_Init_Config(void) {
GPIO_InitTypeDef GPIO_InitStructure;
// 使能GPIO时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |
RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);
// 水泵控制引脚 (PC0)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_ResetBits(GPIOC, GPIO_Pin_0); // 默认关闭
// 加热灯控制引脚 (PC1)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_ResetBits(GPIOC, GPIO_Pin_1); // 默认关闭
// 蜂鸣器引脚 (PC2)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_ResetBits(GPIOC, GPIO_Pin_2); // 默认关闭
// LED状态指示灯 (PC3)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_ResetBits(GPIOC, GPIO_Pin_3); // 默认关闭
}
// 定时器初始化配置
void Timer_Init_Config(void) {
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
// 使能定时器时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
// 配置定时器2为1ms中断
TIM_TimeBaseStructure.TIM_Period = 999;
TIM_TimeBaseStructure.TIM_Prescaler = 71;
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
// 使能定时器中断
TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
// 配置NVIC
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// 启动定时器
TIM_Cmd(TIM2, ENABLE);
}
// USART初始化配置
void USART_Init_Config(void) {
USART_InitTypeDef USART_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
// 使能USART1时钟 (用于调试)
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
// 配置USART1 Tx (PA9)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// 配置USART1 Rx (PA10)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// USART1配置 (调试串口)
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART1, &USART_InitStructure);
USART_Cmd(USART1, ENABLE);
// 使能USART2时钟 (用于ESP8266)
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
// 配置USART2 Tx (PA2)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// 配置USART2 Rx (PA3)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// USART2配置 (ESP8266)
USART_InitStructure.USART_BaudRate = 115200;
USART_Init(USART2, &USART_InitStructure);
USART_Cmd(USART2, ENABLE);
}
// I2C初始化配置
void I2C_Init_Config(void) {
I2C_InitTypeDef I2C_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
// 使能I2C1时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
// 配置I2C1 SCL (PB6)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// 配置I2C1 SDA (PB7)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// I2C1配置
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_OwnAddress1 = 0x30;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = 100000; // 100kHz
I2C_Init(I2C1, &I2C_InitStructure);
I2C_Cmd(I2C1, ENABLE);
}
// ADC初始化配置
void ADC_Init_Config(void) {
ADC_InitTypeDef ADC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
// 使能ADC1时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA, ENABLE);
// 配置ADC引脚 (PA0, PA1, PA4, PA5, PA6, PA7)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_4 |
GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// ADC配置
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 6;
ADC_Init(ADC1, &ADC_InitStructure);
// 配置ADC通道
ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_55Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 2, ADC_SampleTime_55Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_4, 3, ADC_SampleTime_55Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_5, 4, ADC_SampleTime_55Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_6, 5, ADC_SampleTime_55Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_7, 6, ADC_SampleTime_55Cycles5);
// 启动ADC
ADC_Cmd(ADC1, ENABLE);
ADC_ResetCalibration(ADC1);
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
}
// 读取所有传感器数据
void Sensor_Read_All(void) {
// 读取土壤温湿度 (SHT30)
if (SHT30_Read(&g_sensor_data.soil_temperature, &g_sensor_data.soil_humidity) == 0) {
printf("土壤温湿度读取失败\r\n");
}
// 读取CO2浓度 (MH-Z19B)
g_sensor_data.air_co2 = MHZ19B_Read_CO2();
if (g_sensor_data.air_co2 == 0) {
printf("CO2传感器读取失败\r\n");
}
// 读取光照强度 (BH1750)
g_sensor_data.light_intensity = BH1750_Read_Lux();
if (g_sensor_data.light_intensity == 0) {
printf("光照传感器读取失败\r\n");
}
// 更新时间戳
g_sensor_data.timestamp = millis();
printf("传感器数据: 温度=%.1f°C, 湿度=%.1f%%, CO2=%.0fppm, 光照=%.0flux\r\n",
g_sensor_data.soil_temperature, g_sensor_data.soil_humidity,
g_sensor_data.air_co2, g_sensor_data.light_intensity);
}
// 执行自动控制
void Control_Execute(void) {
CropTemplate *crop = &g_crop_templates[g_system_status.current_crop];
// 水泵控制 (土壤湿度)
if (g_sensor_data.soil_humidity < crop->soil_humidity_min) {
// 土壤湿度过低，开启水泵
GPIO_SetBits(GPIOC, GPIO_Pin_0);
g_system_status.pump_status = 1;
printf("土壤湿度过低，开启水泵灌溉\r\n");
} else if (g_sensor_data.soil_humidity > crop->soil_humidity_max) {
// 土壤湿度过高，关闭水泵
GPIO_ResetBits(GPIOC, GPIO_Pin_0);
g_system_status.pump_status = 0;
printf("土壤湿度过高，关闭水泵\r\n");
}
// 加热灯控制 (土壤温度)
if (g_sensor_data.soil_temperature < crop->soil_temp_min) {
// 温度过低，开启加热灯
GPIO_SetBits(GPIOC, GPIO_Pin_1);
g_system_status.heater_status = 1;
printf("温度过低，开启加热灯\r\n");
} else if (g_sensor_data.soil_temperature > crop->soil_temp_max) {
// 温度过高，关闭加热灯
GPIO_ResetBits(GPIOC, GPIO_Pin_1);
g_system_status.heater_status = 0;
printf("温度过高，关闭加热灯\r\n");
}
}
// 数据上传
void Data_Upload(void) {
if (g_system_status.wifi_connected) {
char json_buffer[256];
CropTemplate *crop = &g_crop_templates[g_system_status.current_crop];
// 构建JSON数据
snprintf(json_buffer, sizeof(json_buffer),
"{\"node_id\":%d,\"timestamp\":%lu,\"soil_temp\":%.1f,\"soil_humidity\":%.1f,\"co2\":%.0f,\"light\":%.0f,\"pump\":%d,\"heater\":%d,\"crop\":\"%s\"}",
NODE_ID, g_sensor_data.timestamp,
g_sensor_data.soil_temperature, g_sensor_data.soil_humidity,
g_sensor_data.air_co2, g_sensor_data.light_intensity,
g_system_status.pump_status, g_system_status.heater_status,
crop->name);
// 通过ESP8266发送数据
if (ESP8266_Send_Data(json_buffer) == 0) {
printf("数据上传成功\r\n");
GPIO_SetBits(GPIOC, GPIO_Pin_3); // 点亮状态LED
Delay_ms(100);
GPIO_ResetBits(GPIOC, GPIO_Pin_3);
} else {
printf("数据上传失败\r\n");
}
} else {
printf("WiFi未连接，跳过数据上传\r\n");
}
}
// OLED显示数据
void OLED_Display_Data(void) {
char display_buffer[32];
CropTemplate *crop = &g_crop_templates[g_system_status.current_crop];
// 清空屏幕
SSD1306_Clear();
// 显示标题
SSD1306_SetCursor(0, 0);
SSD1306_WriteString("智能大棚监控系统", Font_7x10);
// 显示节点ID和作物
SSD1306_SetCursor(0, 12);
snprintf(display_buffer, sizeof(display_buffer), "节点:%d 作物:%s", NODE_ID, crop->name);
SSD1306_WriteString(display_buffer, Font_6x8);
// 显示传感器数据
SSD1306_SetCursor(0, 22);
snprintf(display_buffer, sizeof(display_buffer), "土温:%.1fC 土湿:%.1f%%",
g_sensor_data.soil_temperature, g_sensor_data.soil_humidity);
SSD1306_WriteString(display_buffer, Font_6x8);
SSD1306_SetCursor(0, 32);
snprintf(display_buffer, sizeof(display_buffer), "CO2:%.0fppm 光照:%.0flux",
g_sensor_data.air_co2, g_sensor_data.light_intensity);
SSD1306_WriteString(display_buffer, Font_6x8);
// 显示执行器状态
SSD1306_SetCursor(0, 42);
snprintf(display_buffer, sizeof(display_buffer), "水泵:%s 加热:%s",
g_system_status.pump_status ? "开" : "关",
g_system_status.heater_status ? "开" : "关");
SSD1306_WriteString(display_buffer, Font_6x8);
// 显示WiFi状态
SSD1306_SetCursor(0, 52);
snprintf(display_buffer, sizeof(display_buffer), "WiFi:%s 模式:%s",
g_system_status.wifi_connected ? "已连接" : "未连接",
g_system_status.auto_mode ? "自动" : "手动");
SSD1306_WriteString(display_buffer, Font_6x8);
// 更新显示
SSD1306_UpdateScreen();
}
// 报警检查
void Alarm_Check(void) {
static uint32_t last_alarm_time = 0;
uint32_t current_time = millis();
CropTemplate *crop = &g_crop_templates[g_system_status.current_crop];
uint8_t need_alarm = 0;
// 检查各项参数是否超出范围
if (g_sensor_data.soil_temperature < crop->soil_temp_min ||
g_sensor_data.soil_temperature > crop->soil_temp_max) {
need_alarm = 1;
}
if (g_sensor_data.soil_humidity < crop->soil_humidity_min ||
g_sensor_data.soil_humidity > crop->soil_humidity_max) {
need_alarm = 1;
}
if (g_sensor_data.air_co2 < crop->co2_min ||
g_sensor_data.air_co2 > crop->co2_max) {
need_alarm = 1;
}
if (g_sensor_data.light_intensity < crop->light_min ||
g_sensor_data.light_intensity > crop->light_max) {
need_alarm = 1;
}
// 触发报警
if (need_alarm && (current_time - last_alarm_time > 10000)) { // 10秒间隔
printf("参数异常报警！\r\n");
// 本地蜂鸣器报警
GPIO_SetBits(GPIOC, GPIO_Pin_2);
Delay_ms(500);
GPIO_ResetBits(GPIOC, GPIO_Pin_2);
last_alarm_time = current_time;
}
}
// 延时函数
void Delay_ms(uint32_t ms) {
uint32_t i;
for (i = 0; i < ms; i++) {
Delay_us(1000);
}
}
void Delay_us(uint32_t us) {
uint32_t count = us * 8; // 72MHz时钟
while (count--) {
__NOP();
}
}
// 获取系统运行时间 (毫秒)
uint32_t millis(void) {
return TIM2->CNT; // 简化的毫秒计数
}
// 定时器2中断服务函数
void TIM2_IRQHandler(void) {
if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) {
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
// 毫秒计数器更新
static uint32_t ms_counter = 0;
ms_counter++;
}
}
// printf重定向
int fputc(int ch, FILE *f) {
USART_SendData(USART1, (uint8_t)ch);
while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
return ch;
}
|
2203_75618979/Agriculture1
|
stm32_main.c
|
C
|
unknown
| 19,138
|
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>智能农业大棚监控系统</title>
<!-- 国内CDN资源 -->
<script src="https://cdn.tailwindcss.com"></script>
<link href="https://cdn.bootcdn.net/ajax/libs/daisyui/4.12.10/full.min.css" rel="stylesheet">
<link href="https://cdn.bootcdn.net/ajax/libs/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
<script src="https://cdn.bootcdn.net/ajax/libs/Chart.js/4.4.0/chart.min.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/axios/1.6.7/axios.min.js"></script>
<style>
.status-online { color: #10b981; }
.status-offline { color: #ef4444; }
.chart-container { position: relative; height: 300px; }
.sensor-card { transition: all 0.3s ease; }
.sensor-card:hover { transform: translateY(-2px); }
</style>
</head>
<body class="bg-gray-50">
<div class="container mx-auto px-4 py-6">
<!-- 页面标题 -->
<div class="text-center mb-8">
<h1 class="text-4xl font-bold text-green-600 mb-2">
<i class="fas fa-seedling mr-3"></i>智能农业大棚监控系统
</h1>
<p class="text-gray-600">实时监控 · 智能控制 · 数据分析</p>
</div>
<!-- 系统状态概览 -->
<div class="grid grid-cols-1 md:grid-cols-4 gap-6 mb-8">
<div class="stats shadow bg-white">
<div class="stat">
<div class="stat-figure text-primary">
<i class="fas fa-network-wired text-3xl"></i>
</div>
<div class="stat-title">总节点数</div>
<div class="stat-value text-primary" id="total-nodes">0</div>
</div>
</div>
<div class="stats shadow bg-white">
<div class="stat">
<div class="stat-figure text-success">
<i class="fas fa-wifi text-3xl"></i>
</div>
<div class="stat-title">在线节点</div>
<div class="stat-value text-success" id="online-nodes">0</div>
</div>
</div>
<div class="stats shadow bg-white">
<div class="stat">
<div class="stat-figure text-warning">
<i class="fas fa-thermometer-half text-3xl"></i>
</div>
<div class="stat-title">平均温度</div>
<div class="stat-value text-warning" id="avg-temp">--°C</div>
</div>
</div>
<div class="stats shadow bg-white">
<div class="stat">
<div class="stat-figure text-info">
<i class="fas fa-tint text-3xl"></i>
</div>
<div class="stat-title">平均湿度</div>
<div class="stat-value text-info" id="avg-humidity">--%</div>
</div>
</div>
</div>
<!-- 控制面板 -->
<div class="grid grid-cols-1 lg:grid-cols-3 gap-6 mb-8">
<!-- 作物模板选择 -->
<div class="card bg-white shadow-xl">
<div class="card-body">
<h2 class="card-title">
<i class="fas fa-leaf text-green-500"></i>
作物模板
</h2>
<div class="form-control">
<label class="label">
<span class="label-text">选择作物类型</span>
</label>
<select class="select select-bordered" id="crop-template">
<option value="tomato">🍅 番茄</option>
<option value="strawberry">🍓 草莓</option>
<option value="general">🌱 通用</option>
</select>
</div>
<div class="form-control">
<label class="label">
<span class="label-text">目标节点</span>
</label>
<select class="select select-bordered" id="target-node">
<option value="1">节点 1</option>
</select>
</div>
<button class="btn btn-primary" onclick="applyTemplate()">
<i class="fas fa-magic mr-2"></i>应用模板
</button>
</div>
</div>
<!-- 手动控制 -->
<div class="card bg-white shadow-xl">
<div class="card-body">
<h2 class="card-title">
<i class="fas fa-sliders-h text-blue-500"></i>
手动控制
</h2>
<div class="form-control">
<label class="label cursor-pointer">
<span class="label-text">水泵</span>
<input type="checkbox" class="toggle toggle-primary" id="pump-toggle">
</label>
</div>
<div class="form-control">
<label class="label cursor-pointer">
<span class="label-text">加热灯</span>
<input type="checkbox" class="toggle toggle-secondary" id="heater-toggle">
</label>
</div>
<div class="form-control">
<label class="label">
<span class="label-text">目标节点</span>
</label>
<select class="select select-bordered" id="control-node">
<option value="1">节点 1</option>
</select>
</div>
<button class="btn btn-secondary" onclick="sendControlCommand()">
<i class="fas fa-paper-plane mr-2"></i>发送命令
</button>
</div>
</div>
<!-- 报警状态 -->
<div class="card bg-white shadow-xl">
<div class="card-body">
<h2 class="card-title">
<i class="fas fa-exclamation-triangle text-red-500"></i>
报警状态
</h2>
<div id="alarm-status" class="space-y-2">
<div class="alert alert-success">
<i class="fas fa-check-circle"></i>
<span>系统运行正常</span>
</div>
</div>
<button class="btn btn-ghost btn-sm" onclick="refreshAlarms()">
<i class="fas fa-sync-alt mr-2"></i>刷新状态
</button>
</div>
</div>
</div>
<!-- 数据图表 -->
<div class="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-8">
<!-- 温度趋势图 -->
<div class="card bg-white shadow-xl">
<div class="card-body">
<h2 class="card-title">
<i class="fas fa-chart-line text-red-500"></i>
温度趋势
</h2>
<div class="chart-container">
<canvas id="temp-chart"></canvas>
</div>
</div>
</div>
<!-- 湿度趋势图 -->
<div class="card bg-white shadow-xl">
<div class="card-body">
<h2 class="card-title">
<i class="fas fa-chart-area text-blue-500"></i>
湿度趋势
</h2>
<div class="chart-container">
<canvas id="humidity-chart"></canvas>
</div>
</div>
</div>
</div>
<!-- 节点详情 -->
<div class="card bg-white shadow-xl">
<div class="card-body">
<h2 class="card-title">
<i class="fas fa-info-circle text-info"></i>
节点详情
</h2>
<div class="overflow-x-auto">
<table class="table table-zebra w-full">
<thead>
<tr>
<th>节点ID</th>
<th>状态</th>
<th>土壤温度(°C)</th>
<th>土壤湿度(%)</th>
<th>CO2浓度(ppm)</th>
<th>光照强度(lux)</th>
<th>水泵</th>
<th>加热灯</th>
<th>最后更新</th>
</tr>
</thead>
<tbody id="nodes-table">
<tr>
<td colspan="9" class="text-center text-gray-500">
<i class="fas fa-spinner fa-spin mr-2"></i>加载中...
</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
</div>
<!-- 页脚 -->
<footer class="footer footer-center p-4 bg-base-300 text-base-content mt-8">
<div>
<p>智能农业大棚监控系统 © 2024 - 基于STM32 + Flask</p>
</div>
</footer>
<script>
// 全局变量
let tempChart, humidityChart;
let dataHistory = {
timestamps: [],
temperatures: [],
humidities: []
};
let maxDataPoints = 20;
// 初始化图表
function initCharts() {
const chartOptions = {
responsive: true,
maintainAspectRatio: false,
plugins: {
legend: {
display: true,
position: 'top'
}
},
scales: {
y: {
beginAtZero: false
}
}
};
// 温度图表
const tempCtx = document.getElementById('temp-chart').getContext('2d');
tempChart = new Chart(tempCtx, {
type: 'line',
data: {
labels: dataHistory.timestamps,
datasets: [{
label: '土壤温度 (°C)',
data: dataHistory.temperatures,
borderColor: 'rgb(239, 68, 68)',
backgroundColor: 'rgba(239, 68, 68, 0.1)',
tension: 0.4
}]
},
options: chartOptions
});
// 湿度图表
const humidityCtx = document.getElementById('humidity-chart').getContext('2d');
humidityChart = new Chart(humidityCtx, {
type: 'line',
data: {
labels: dataHistory.timestamps,
datasets: [{
label: '土壤湿度 (%)',
data: dataHistory.humidities,
borderColor: 'rgb(59, 130, 246)',
backgroundColor: 'rgba(59, 130, 246, 0.1)',
tension: 0.4
}]
},
options: chartOptions
});
}
// 更新图表数据
function updateChartData(data) {
const now = new Date().toLocaleTimeString();
dataHistory.timestamps.push(now);
dataHistory.temperatures.push(data.soil_temp);
dataHistory.humidities.push(data.soil_humidity);
// 保持数据点数量
if (dataHistory.timestamps.length > maxDataPoints) {
dataHistory.timestamps.shift();
dataHistory.temperatures.shift();
dataHistory.humidities.shift();
}
// 更新图表
tempChart.data.labels = dataHistory.timestamps;
tempChart.data.datasets[0].data = dataHistory.temperatures;
tempChart.update();
humidityChart.data.labels = dataHistory.timestamps;
humidityChart.data.datasets[0].data = dataHistory.humidities;
humidityChart.update();
}
// 获取系统数据
async function fetchData() {
try {
const response = await axios.get('/api/data');
const data = response.data;
// 更新系统状态
document.getElementById('total-nodes').textContent = data.system_status.total_nodes;
document.getElementById('online-nodes').textContent = data.system_status.online_nodes;
// 计算平均值
let totalTemp = 0, totalHumidity = 0, count = 0;
for (const nodeId in data.nodes) {
const node = data.nodes[nodeId];
if (node.status === 'online') {
totalTemp += node.soil_temp;
totalHumidity += node.soil_humidity;
count++;
}
}
if (count > 0) {
document.getElementById('avg-temp').textContent = (totalTemp / count).toFixed(1) + '°C';
document.getElementById('avg-humidity').textContent = (totalHumidity / count).toFixed(1) + '%';
}
// 更新节点表格
updateNodesTable(data.nodes);
// 更新图表（如果有在线节点）
if (count > 0) {
const firstNode = Object.values(data.nodes)[0];
updateChartData(firstNode);
}
} catch (error) {
console.error('获取数据失败:', error);
}
}
// 更新节点表格
function updateNodesTable(nodes) {
const tbody = document.getElementById('nodes-table');
tbody.innerHTML = '';
if (Object.keys(nodes).length === 0) {
tbody.innerHTML = '<tr><td colspan="9" class="text-center text-gray-500">暂无节点数据</td></tr>';
return;
}
for (const nodeId in nodes) {
const node = nodes[nodeId];
const statusClass = node.status === 'online' ? 'status-online' : 'status-offline';
const statusIcon = node.status === 'online' ? 'fa-wifi' : 'fa-wifi-slash';
const pumpStatus = node.pump_status ? '<span class="badge badge-success">开启</span>' : '<span class="badge badge-error">关闭</span>';
const heaterStatus = node.heater_status ? '<span class="badge badge-success">开启</span>' : '<span class="badge badge-error">关闭</span>';
const lastUpdate = new Date(node.timestamp * 1000).toLocaleTimeString();
const row = `
<tr class="sensor-card">
<td>${node.node_id}</td>
<td><span class="${statusClass}"><i class="fas ${statusIcon} mr-1"></i>${node.status === 'online' ? '在线' : '离线'}</span></td>
<td>${node.soil_temp.toFixed(1)}</td>
<td>${node.soil_humidity.toFixed(1)}</td>
<td>${node.co2}</td>
<td>${node.light.toLocaleString()}</td>
<td>${pumpStatus}</td>
<td>${heaterStatus}</td>
<td>${lastUpdate}</td>
</tr>
`;
tbody.innerHTML += row;
}
}
// 应用作物模板
async function applyTemplate() {
const template = document.getElementById('crop-template').value;
const nodeId = document.getElementById('target-node').value;
try {
const response = await axios.post(`/api/templates/${template}`, {
node_id: nodeId
});
if (response.data.status === 'success') {
alert(`成功应用${response.data.template.name}模板到节点${nodeId}`);
}
} catch (error) {
alert('应用模板失败: ' + error.message);
}
}
// 发送控制命令
async function sendControlCommand() {
const nodeId = document.getElementById('control-node').value;
const pumpStatus = document.getElementById('
|
2203_75618979/Agriculture1
|
templates/index.html
|
HTML
|
unknown
| 17,576
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<head>
<TITLE> 爱你❤ </TITLE>
<META NAME="Generator" CONTENT="EditPlus">
<META NAME="Author" CONTENT="">
<META NAME="Keywords" CONTENT="">
<META NAME="Description" CONTENT="">
<style>
html, body {
height: 100%;
padding: 0;
margin: 0;
background: #000;
}
canvas {
position: absolute;
width: 100%;
height: 100%;
}
div {
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
width: 250px;
height: 100px;
}
</style>
</head>
<BODY>
<canvas id="c"></canvas>
<audio autoplay="autoplay" loop="loop" preload="auto" id="music">
<source src="目及皆是你.mp3" type="audio/mpeg">
</audio>
<div> <iframe src="文字.html" height="100%" width="100%" scrolling="no" frameborder="0">
</iframe>
</div>
<script>
var c=document.getElementById("c");
var ctx=c.getContext("2d");
c.width=window.innerWidth;
c.height=window.innerHeight;
// ctx.fillRect(0,0,100,100);
// a,b,c,d分别代表x方向偏移,y方向偏移,宽，高
var string1 = "abcdefghijklmnopqrstuvwxyz";
string1.split("");
var fontsize=20;
columns=c.width/fontsize;
var drop = [];
for(var x=0;x<columns;x++)
{
drop[x]=0;
}
function drap(){
ctx.fillStyle="rgba(0,0,0,0.07)";
ctx.fillRect(0,0,c.width,c.height);
ctx.fillStyle="#ea80b0";
ctx.font=fontsize+"px arial";
for(var i=0;i<drop.length;i++){
var text1=string1[Math.floor(Math.random()*string1.length)];
ctx.fillText(text1,i*fontsize,drop[i]*fontsize);
drop[i]++;
if(drop[i]*fontsize>c.height&&Math.random()>0.9){//90%的几率掉落
drop[i]=0;
}
}
}
setInterval(drap,50);
</script>
<canvas id="pinkboard"></canvas>
<script>
/*
* Settings
*/
var settings = {
particles: {
length: 500, // maximum amount of particles
duration: 2, // particle duration in sec
velocity: 100, // particle velocity in pixels/sec
effect: -0.75, // play with this for a nice effect
size: 30, // particle size in pixels
},
};
/*
* RequestAnimationFrame polyfill by Erik Möller
*/
(function(){var b=0;var c=["ms","moz","webkit","o"];for(var a=0;a<c.length&&!window.requestAnimationFrame;++a){window.requestAnimationFrame=window[c[a]+"RequestAnimationFrame"];window.cancelAnimationFrame=window[c[a]+"CancelAnimationFrame"]||window[c[a]+"CancelRequestAnimationFrame"]}if(!window.requestAnimationFrame){window.requestAnimationFrame=function(h,e){var d=new Date().getTime();var f=Math.max(0,16-(d-b));var g=window.setTimeout(function(){h(d+f)},f);b=d+f;return g}}if(!window.cancelAnimationFrame){window.cancelAnimationFrame=function(d){clearTimeout(d)}}}());
/*
* Point class
*/
var Point = (function() {
function Point(x, y) {
this.x = (typeof x !== 'undefined') ? x : 0;
this.y = (typeof y !== 'undefined') ? y : 0;
}
Point.prototype.clone = function() {
return new Point(this.x, this.y);
};
Point.prototype.length = function(length) {
if (typeof length == 'undefined')
return Math.sqrt(this.x * this.x + this.y * this.y);
this.normalize();
this.x *= length;
this.y *= length;
return this;
};
Point.prototype.normalize = function() {
var length = this.length();
this.x /= length;
this.y /= length;
return this;
};
return Point;
})();
/*
* Particle class
*/
var Particle = (function() {
function Particle() {
this.position = new Point();
this.velocity = new Point();
this.acceleration = new Point();
this.age = 0;
}
Particle.prototype.initialize = function(x, y, dx, dy) {
this.position.x = x;
this.position.y = y;
this.velocity.x = dx;
this.velocity.y = dy;
this.acceleration.x = dx * settings.particles.effect;
this.acceleration.y = dy * settings.particles.effect;
this.age = 0;
};
Particle.prototype.update = function(deltaTime) {
this.position.x += this.velocity.x * deltaTime;
this.position.y += this.velocity.y * deltaTime;
this.velocity.x += this.acceleration.x * deltaTime;
this.velocity.y += this.acceleration.y * deltaTime;
this.age += deltaTime;
};
Particle.prototype.draw = function(context, image) {
function ease(t) {
return (--t) * t * t + 1;
}
var size = image.width * ease(this.age / settings.particles.duration);
context.globalAlpha = 1 - this.age / settings.particles.duration;
context.drawImage(image, this.position.x - size / 2, this.position.y - size / 2, size, size);
};
return Particle;
})();
/*
* ParticlePool class
*/
var ParticlePool = (function() {
var particles,
firstActive = 0,
firstFree = 0,
duration = settings.particles.duration;
function ParticlePool(length) {
// create and populate particle pool
particles = new Array(length);
for (var i = 0; i < particles.length; i++)
particles[i] = new Particle();
}
ParticlePool.prototype.add = function(x, y, dx, dy) {
particles[firstFree].initialize(x, y, dx, dy);
// handle circular queue
firstFree++;
if (firstFree == particles.length) firstFree = 0;
if (firstActive == firstFree ) firstActive++;
if (firstActive == particles.length) firstActive = 0;
};
ParticlePool.prototype.update = function(deltaTime) {
var i;
// update active particles
if (firstActive < firstFree) {
for (i = firstActive; i < firstFree; i++)
particles[i].update(deltaTime);
}
if (firstFree < firstActive) {
for (i = firstActive; i < particles.length; i++)
particles[i].update(deltaTime);
for (i = 0; i < firstFree; i++)
particles[i].update(deltaTime);
}
// remove inactive particles
while (particles[firstActive].age >= duration && firstActive != firstFree) {
firstActive++;
if (firstActive == particles.length) firstActive = 0;
}
};
ParticlePool.prototype.draw = function(context, image) {
// draw active particles
if (firstActive < firstFree) {
for (i = firstActive; i < firstFree; i++)
particles[i].draw(context, image);
}
if (firstFree < firstActive) {
for (i = firstActive; i < particles.length; i++)
particles[i].draw(context, image);
for (i = 0; i < firstFree; i++)
particles[i].draw(context, image);
}
};
return ParticlePool;
})();
/*
* Putting it all together
*/
(function(canvas) {
var context = canvas.getContext('2d'),
particles = new ParticlePool(settings.particles.length),
particleRate = settings.particles.length / settings.particles.duration, // particles/sec
time;
// get point on heart with -PI <= t <= PI
function pointOnHeart(t) {
return new Point(
160 * Math.pow(Math.sin(t), 3),
130 * Math.cos(t) - 50 * Math.cos(2 * t) - 20 * Math.cos(3 * t) - 10 * Math.cos(4 * t) + 25
);
}
// creating the particle image using a dummy canvas
var image = (function() {
var canvas = document.createElement('canvas'),
context = canvas.getContext('2d');
canvas.width = settings.particles.size;
canvas.height = settings.particles.size;
// helper function to create the path
function to(t) {
var point = pointOnHeart(t);
point.x = settings.particles.size / 2 + point.x * settings.particles.size / 350;
point.y = settings.particles.size / 2 - point.y * settings.particles.size / 350;
return point;
}
// create the path
context.beginPath();
var t = -Math.PI;
var point = to(t);
context.moveTo(point.x, point.y);
while (t < Math.PI) {
t += 0.01; // baby steps!
point = to(t);
context.lineTo(point.x, point.y);
}
context.closePath();
// create the fill
context.fillStyle = '#ea80b0';
context.fill();
// create the image
var image = new Image();
image.src = canvas.toDataURL();
return image;
})();
// render that thing!
function render() {
// next animation frame
requestAnimationFrame(render);
// update time
var newTime = new Date().getTime() / 1000,
deltaTime = newTime - (time || newTime);
time = newTime;
// clear canvas
context.clearRect(0, 0, canvas.width, canvas.height);
// create new particles
var amount = particleRate * deltaTime;
for (var i = 0; i < amount; i++) {
var pos = pointOnHeart(Math.PI - 2 * Math.PI * Math.random());
var dir = pos.clone().length(settings.particles.velocity);
particles.add(canvas.width / 2 + pos.x, canvas.height / 2 - pos.y, dir.x, -dir.y);
}
// update and draw particles
particles.update(deltaTime);
particles.draw(context, image);
}
// handle (re-)sizing of the canvas
function onResize() {
canvas.width = canvas.clientWidth;
canvas.height = canvas.clientHeight;
}
window.onresize = onResize;
// delay rendering bootstrap
setTimeout(function() {
onResize();
render();
}, 10);
})(document.getElementById('pinkboard'));
</script>
<script type="text/javascript">
window.onload = function(){
setInterval("toggleSound()",1);
}
function toggleSound() {
var music = document.getElementById("music");//获取ID
if (music.paused) { //判读是否播放
music.paused=false;
music.play(); //没有就播放
}
}
</script>
</BODY>
</HTML>
|
2301_76142921/521
|
index.html
|
HTML
|
unknown
| 10,015
|
// 获取页面中的content元素，后续用于展示内容
const contentDiv = document.getElementById('content');
contentDiv.classList.add('content'); // 为contentDiv添加content类名，应用相关样式
// 定义字符型数组a1
//const a1 = ['爱', '就要', '勇敢', '说', '出来'];
const a1 = ['那一刻', '我以为', '可以', '永远', '在一起','但'];
// 定义普通字符类型a2
//const a2 = 'XXX💖XXX';
const a2 = '我们还可以再见吗';
// 按顺序展示数组a1元素的函数，每个元素展示2秒
function showArrayA1() {
let index = 0;
function showNextElement() {
if (index < a1.length) {
contentDiv.textContent = a1[index];
index++;
setTimeout(showNextElement, 2000);
} else {
setTimeout(() => {
contentDiv.textContent = '';
showArrayA2();
}, 1000);
}
}
showNextElement();
}
// 自定义函数，用于修改a1展示时的字体大小
function setA1FontSize(size) {
contentDiv.style.fontSize = `${size}px`;
}
// 展示a2内容的函数，按照设定的CSS样式展示
function showArrayA2() {
const p = document.createElement('p');
p.textContent = a2;
contentDiv.appendChild(p);
}
// 自定义函数，用于修改a2展示时的字体大小
function setA2FontSize(size) {
const p = contentDiv.querySelector('p');
if (p) {
p.style.fontSize = `${size}px`;
}
}
// 页面加载完成后执行展示逻辑
window.onload = function () {
showArrayA1();
};
|
2301_76142921/521
|
script.js
|
JavaScript
|
unknown
| 1,573
|
html,
body {
margin: 0;
padding: 0;
width: 100%;
height: 100%;
overflow: hidden;
}
canvas {
width: 100%;
height: 100%;
background-color: black;
}
|
2301_76142921/521
|
styles.css
|
CSS
|
unknown
| 178
|
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Array Display Page</title>
<style>
html,
body {
margin: 0;
padding: 0;
width: 100%;
height: 100%;
display: flex;
justify-content: center;
align-items: center;
}
body {
width: 250px;
height: 100px;
background-color: transparent; /* 将body背景设置为透明 */
}
.content {
font-size: 60px; /* 设置默认字体大小，可根据需求调整，这里用于a1展示 */
text-align: center;
width: 100%;
height: 100%;
display: flex;
justify-content: center;
align-items: center;
color: #ff0000;
}
p {
margin: 0;
width: 100%;
height: 100%;
display: flex;
justify-content: center;
align-items: center;
background: -webkit-linear-gradient(left,
#ffffff,
#ff0000 6.25%,
#ff7d00 12.5%,
#ffff00 18.75%,
#00ff00 25%,
#00ffff 31.25%,
#0000ff 37.5%,
#ff00ff 43.75%,
#ffff00 50%,
#ff0000 56.25%,
#ff7d00 62.5%,
#ffff00 68.75%,
#00ff00 75%,
#00ffff 81.25%,
#0000ff 87.5%,
#ff00ff 93.75%,
#ffff00 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-size: 200% 100%;
animation: masked-animation 2s infinite linear;
font-size: 33px; /* 设置默认字体大小，可根据需求调整，这里用于a2展示 */
}
@keyframes masked-animation {
0% {
background-position: 0 0;
}
100% {
background-position: -100% 0;
}
}
</style>
</head>
<body>
<div id="content"></div>
<script src="script.js"></script>
</body>
</html>
|
2301_76142921/521
|
文字.html
|
HTML
|
unknown
| 2,372
|
<script>
export default {
onLaunch: function() {
console.warn('当前组件仅支持 uni_modules 目录结构 ，请升级 HBuilderX 到 3.1.0 版本以上！')
console.log('App Launch')
},
onShow: function() {
console.log('App Show')
},
onHide: function() {
console.log('App Hide')
}
}
</script>
<style lang="scss">
/*每个页面公共css */
@import '@/uni_modules/uni-scss/index.scss';
/* #ifndef APP-NVUE */
@import '@/static/customicons.css';
// 设置整个项目的背景色
page {
background-color: #f5f5f5;
}
/* #endif */
.example-info {
font-size: 14px;
color: #333;
padding: 10px;
}
</style>
|
2202_75391616/ui
|
App.vue
|
Vue
|
unknown
| 649
|