diff --git a/ChanBIZS.py b/ChanBIZS.py index 464f3a6..91a1442 100644 --- a/ChanBIZS.py +++ b/ChanBIZS.py @@ -1,4 +1,4 @@ -from ChanEnum import Chan_ZS_DIR +from ChanEnum import Chan_ZS_DIR, Chan_ZS_TYPE, Chan_BI_DIR import ChanBI # 中枢 class ChanBIZS(): @@ -20,12 +20,13 @@ class ChanBIZS(): self.dir = ddir self.sure_time = None self.end_klc = None + self.zs_type = Chan_ZS_TYPE.NORMAL def set_end_bi(self, end_bi, sure_bi): self.end_bi = end_bi self.set_end_time(end_bi.end_klc.end_time) self.is_sure = True self.sure_time = sure_bi.sure_time - # print(self.start_time, self.is_sure, len(self.bi_list), self.dir) + print(self.start_time, self.is_sure, len(self.bi_list), self.dir, self.zs_type) def set_end_time(self, end_time): self.end_time = end_time def set_zg(self, zg): @@ -38,4 +39,113 @@ class ChanBIZS(): self.dd = dd def add_bi(self, bi: ChanBI): if bi: - self.bi_list.append(bi) \ No newline at end of file + self.bi_list.append(bi) + self.classify_zs() + + def classify_zs(self): + """ + 根据中枢内笔的高低点变化趋势，对中枢进行分类 + + 分类逻辑： + - 取中枢内向上笔的高点（peaks）和向下笔的低点（valleys） + - 比较前半段和后半段的均值，判断高点和低点的整体趋势 + + 分类结果： + - RISING 上升中枢：高点抬高 + 低点抬高 → 多方占优，可能向上突破 + - FALLING 下行中枢：高点降低 + 低点降低 → 空方占优，可能向下突破 + - CONVERGING 收敛中枢：高点降低 + 低点抬高 → 区间收窄，即将选择方向 + - DIVERGING 扩散中枢：高点抬高 + 低点降低 → 波动加剧，市场不稳定 + - NORMAL 常规中枢：无明显趋势 → 多空均衡，区间震荡 + """ + if len(self.bi_list) < 3: + self.zs_type = Chan_ZS_TYPE.NORMAL + return + + # 提取向上笔的高点（peaks）和向下笔的低点（valleys） + peaks = [bi.high for bi in self.bi_list if bi.dir == Chan_BI_DIR.UP] + valleys = [bi.low for bi in self.bi_list if bi.dir == Chan_BI_DIR.DOWN] + + high_trend = self._calc_trend(peaks) + low_trend = self._calc_trend(valleys) + + if high_trend > 0 and low_trend > 0: + self.zs_type = Chan_ZS_TYPE.RISING + elif high_trend < 0 and low_trend < 0: + self.zs_type = Chan_ZS_TYPE.FALLING + elif high_trend < 0 and low_trend > 0: + self.zs_type = Chan_ZS_TYPE.CONVERGING + elif high_trend > 0 and low_trend < 0: + self.zs_type = Chan_ZS_TYPE.DIVERGING + else: + self.zs_type = Chan_ZS_TYPE.NORMAL + + def _calc_trend(self, values): + """ + 计算序列的趋势方向 + 将序列分为前后两半，比较均值： + - 后半均值 > 前半均值 → 返回 1（上升趋势） + - 后半均值 < 前半均值 → 返回 -1（下降趋势） + - 相等或数据不足 → 返回 0（无趋势） + + 使用均值比较而非首尾比较，可以过滤单笔异常波动带来的误判 + """ + if len(values) < 2: + return 0 + mid = len(values) // 2 + first_half = values[:mid] if mid > 0 else values[:1] + second_half = values[mid:] + avg_first = sum(first_half) / len(first_half) + avg_second = sum(second_half) / len(second_half) + # 使用中枢区间的一定比例作为阈值，避免微小波动误判 + threshold = abs(avg_first) * 0.005 if avg_first != 0 else 0 + if avg_second - avg_first > threshold: + return 1 + elif avg_first - avg_second > threshold: + return -1 + else: + return 0 + + def is_weakening(self): + """ + 判断中枢是否在衰弱（即将反向突破的信号） + + 衰弱条件： + 1. 中枢内笔数 >= 5（有足够的数据判断） + 2. 最后一笔的MACD面积相比同方向前一笔出现背驰（macd_div < 1） + 3. 中枢类型为收敛型或常规型 + + 返回: True表示中枢力量衰弱，可能反向 + """ + if len(self.bi_list) < 5: + return False + last_bi = self.bi_list[-1] + # 最后一笔与同方向前一笔比较MACD面积是否背驰 + if last_bi.macd_div > 0 and last_bi.macd_div < 1.0: + return True + return False + + def get_zs_strength(self): + """ + 计算中枢强度，用于辅助判断中枢延续还是反向 + + 返回字典包含： + - type: 中枢类型 (Chan_ZS_TYPE) + - bi_count: 中枢内笔数 + - range_ratio: 中枢区间占比 = (zg - zd) / (gg - dd)，越小说明中枢越紧密 + - last_bi_div: 最后一笔的MACD背驰比率 + - is_weakening: 是否衰弱 + - is_extending: 是否在延伸（笔数 >= 9 可能升级） + """ + total_range = self.gg - self.dd if self.gg != self.dd else 1 + zs_range = self.zg - self.zd if self.zg != self.zd else 0 + range_ratio = zs_range / total_range if total_range > 0 else 0 + last_bi_div = self.bi_list[-1].macd_div if len(self.bi_list) > 0 else 0 + + return { + 'type': self.zs_type, + 'bi_count': len(self.bi_list), + 'range_ratio': round(range_ratio, 4), + 'last_bi_div': round(last_bi_div, 4), + 'is_weakening': self.is_weakening(), + 'is_extending': len(self.bi_list) >= 9, # 9段可能升级 + } \ No newline at end of file diff --git a/ChanEnum.py b/ChanEnum.py index 70b12e5..3754d21 100644 --- a/ChanEnum.py +++ b/ChanEnum.py @@ -10,10 +10,42 @@ class Chan_DATA_SRC(Enum): class Chan_ZS_DIR(Enum): UP = auto() DOWN = auto() + +class Chan_ZS_TYPE(Enum): + """中枢类型分类""" + NORMAL = auto() # 常规中枢：高低点无明显趋势，区间震荡 + RISING = auto() # 上升中枢：高点抬高，低点也抬高，重心上移 + FALLING = auto() # 下行中枢：高点降低，低点也降低，重心下移 + CONVERGING = auto() # 收敛中枢：高点降低，低点抬高，区间收窄（三角收敛） + DIVERGING = auto() # 扩散中枢：高点抬高，低点降低，区间扩大（喇叭口） class Chan_K_DIR(Enum): BULL = auto() BEAR = auto() CROSS = auto() + +class Chan_EMA_POS(Enum): + """K线与任意EMA的位置关系（与趋势方向无关的客观分类，支持threshold容差）""" + ABOVE = auto() # 完全在EMA上方（远离）：low > ema + threshold + NEAR_ABOVE = auto() # 在EMA上方但接近：ema < low <= ema + threshold + CROSS_CLOSE_ABOVE = auto() # 跨越EMA，收盘在上方：close > ema, low <= ema（含threshold范围内触碰） + ON_EMA = auto() # 收盘价在EMA附近：abs(close - ema) <= threshold + CROSS_CLOSE_BELOW = auto() # 跨越EMA，收盘在下方：close < ema, high >= ema（含threshold范围内触碰） + NEAR_BELOW = auto() # 在EMA下方但接近：ema - threshold <= high < ema + BELOW = auto() # 完全在EMA下方（远离）：high < ema - threshold + UNKNOWN = auto() # 未知（EMA值无效） + +class Chan_EMA_SEMANTIC(Enum): + """K线与EMA结合趋势方向的语义状态（用于交易判断）""" + STRONG_TREND = auto() # 7: 顺势K线完全在EMA趋势侧（强势，远未及EMA） + TREND_SIDE = auto() # 6: 完全在EMA趋势侧（正常趋势运行） + RECOVER = auto() # 5: 逆势后穿越EMA回到趋势侧（收复EMA，趋势恢复） + TOUCH_FAIL = auto() # 4: 逆势触碰EMA但未穿越（反弹/反抽力度不足） + DEEP_COUNTER = auto() # 3: 完全在EMA逆势侧（深度回调/反抽） + BREAK = auto() # 2: 穿越EMA，收盘在逆势侧（支撑/压力失败） + TOUCH_HOLD = auto() # 1: 触碰EMA，收盘守住趋势侧（支撑/压力有效） + WEAK_COUNTER = auto() # 8: 逆势K线完全在EMA逆势侧（弱势，远未到EMA） + APPROACHING = auto() # 9: K线接近EMA但未触碰（即将测试支撑/压力） + NEUTRAL = auto() # 0: 盘整/无法判断 class Chan_KL_TYPE(Enum): K_1S = auto() K_1M = auto() diff --git a/ChanKLC.py b/ChanKLC.py index 7a2c505..a0d6fc2 100644 --- a/ChanKLC.py +++ b/ChanKLC.py @@ -1,7 +1,7 @@ import copy from typing import Dict, Optional -from ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_KLC_FX, Chan_K_DIR, Chan_MACD_STATE, Chan_PRICE_TREND +from ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_KLC_FX, Chan_K_DIR, Chan_MACD_STATE, Chan_PRICE_TREND, Chan_EMA_POS, Chan_EMA_SEMANTIC import ChanKLU import ChanCTime @@ -45,11 +45,247 @@ class ChanKLC(): self.state = Chan_MACD_STATE.UNKNOWN self.continue_div = False self.separate_div = False - self.ema52 = klu.ema52 self.ema24 = klu.ema24 + self.ema52 = klu.ema52 + self.ema104 = klu.ema104 + self.ema156 = klu.ema156 + self.ema208 = klu.ema208 self.trend = Chan_PRICE_TREND.UNKNOWN self.exception = klu.exception self.klc_dir = Chan_KLINE_DIR.UP if klu.close > klu.open else Chan_KLINE_DIR.DOWN + self.ema_dir = klu.ema_dir + self.bsp = False + # EMA状态字典：key为EMA名称，value为 {'pos': Chan_EMA_POS, 'semantic': Chan_EMA_SEMANTIC} + self.ema_status = {} + # 向后兼容：保留 ema52_status 和 ema52_pos + self.ema52_status = 0 + self.ema52_pos = Chan_EMA_POS.UNKNOWN + self.cal_all_ema_status() + + # ==================== EMA 通用计算方法 ==================== + + @staticmethod + def cal_ema_pos(high, low, close, ema_value, threshold=0): + """ + 计算K线与任意EMA的客观位置关系（与趋势方向无关，支持threshold容差） + + 参数: + high, low, close: K线的高低收盘价 + ema_value: EMA的值 + threshold: 容差值（绝对值），在此范围内视为"接近/触碰" + 例如 BTC 价格 $100,000 时 threshold=100 表示差100点视为触碰 + 返回: + Chan_EMA_POS 枚举值 + + 判断逻辑（以threshold=100, ema=97000为例）： + ema_zone = [96900, 97100] （EMA上下各扩展threshold） + + ABOVE: low > 97100 K线完全在zone上方（远离EMA） + NEAR_ABOVE: 97000 < low <= 97100 K线在上方但下影线进入zone（接近EMA） + CROSS_CLOSE_ABOVE: close > 97000, low <= 97000 K线穿越EMA，收盘在上方 + ON_EMA: abs(close - 97000) <= 100 收盘价在zone内 + CROSS_CLOSE_BELOW: close < 97000, high >= 97000 K线穿越EMA，收盘在下方 + NEAR_BELOW: 96900 <= high < 97000 K线在下方但上影线进入zone（接近EMA） + BELOW: high < 96900 K线完全在zone下方（远离EMA） + """ + if ema_value is None or ema_value == 0: + return Chan_EMA_POS.UNKNOWN + + ema_upper = ema_value + threshold # EMA zone 上界 + ema_lower = ema_value - threshold # EMA zone 下界 + + # 1. 收盘价在EMA附近（zone内） + if threshold > 0 and abs(close - ema_value) <= threshold: + # 收盘价在zone内，但还需要看是否有实际穿越 + if low <= ema_value and close >= ema_value: + return Chan_EMA_POS.CROSS_CLOSE_ABOVE # 实际穿越了精确EMA线 + elif high >= ema_value and close <= ema_value: + return Chan_EMA_POS.CROSS_CLOSE_BELOW + return Chan_EMA_POS.ON_EMA + + # 2. K线实际穿越了精确的EMA线 + if close > ema_value and low <= ema_value: + return Chan_EMA_POS.CROSS_CLOSE_ABOVE + if close < ema_value and high >= ema_value: + return Chan_EMA_POS.CROSS_CLOSE_BELOW + if close == ema_value: + return Chan_EMA_POS.ON_EMA + + # 3. 没有实际穿越，检查是否"接近"（在threshold zone内） + if close > ema_value: + # K线在EMA上方 + if threshold > 0 and low <= ema_upper: + return Chan_EMA_POS.NEAR_ABOVE # 下影线进入zone，接近但未触碰 + return Chan_EMA_POS.ABOVE # 远离EMA + else: + # K线在EMA下方 + if threshold > 0 and high >= ema_lower: + return Chan_EMA_POS.NEAR_BELOW # 上影线进入zone，接近但未触碰 + return Chan_EMA_POS.BELOW # 远离EMA + + @staticmethod + def cal_ema_semantic(ema_pos, kline_dir, ema_dir): + """ + 根据客观位置 + K线方向 + 趋势方向，计算语义状态 + + 参数: + ema_pos: Chan_EMA_POS 客观位置 + kline_dir: Chan_KLINE_DIR K线方向 (UP/DOWN/COMBINE/INCLUDED) + ema_dir: int 趋势方向 (1=多头, -1=空头, 0=盘整) + 返回: + Chan_EMA_SEMANTIC 枚举值 + + 语义含义（以多头为例，空头完全对称）： + TOUCH_HOLD: 触碰EMA，收盘守住趋势侧（支撑/压力有效） + BREAK: 穿越EMA，收盘在逆势侧（支撑/压力失败） + DEEP_COUNTER: 完全在EMA逆势侧（深度回调/反抽） + TOUCH_FAIL: 逆势触碰EMA但未穿越（反弹/反抽力度不足） + RECOVER: 逆势后穿越EMA回到趋势侧（收复EMA） + TREND_SIDE: 完全在EMA趋势侧（正常运行） + STRONG_TREND: 顺势K线完全在EMA趋势侧（强势，远未及EMA） + WEAK_COUNTER: 逆势K线完全在EMA逆势侧（弱势，远未到EMA） + """ + if ema_pos == Chan_EMA_POS.UNKNOWN: + return Chan_EMA_SEMANTIC.NEUTRAL + + # 统一处理：将多头/盘整和空头映射到同一套逻辑 + # is_bull=True 时，"趋势侧"=上方，"逆势侧"=下方 + # is_bull=False时，"趋势侧"=下方，"逆势侧"=上方 + is_bull = ema_dir >= 0 # 多头和盘整都按多头逻辑处理 + + # K线是否是顺势方向（多头下UP为顺势，空头下DOWN为顺势） + is_trend_kline = (kline_dir == Chan_KLINE_DIR.UP) if is_bull else (kline_dir == Chan_KLINE_DIR.DOWN) + is_counter_kline = (kline_dir == Chan_KLINE_DIR.DOWN) if is_bull else (kline_dir == Chan_KLINE_DIR.UP) + + # 位置映射：多头下 ABOVE=趋势侧, BELOW=逆势侧; 空头反过来 + trend_side = Chan_EMA_POS.ABOVE if is_bull else Chan_EMA_POS.BELOW + counter_side = Chan_EMA_POS.BELOW if is_bull else Chan_EMA_POS.ABOVE + near_trend = Chan_EMA_POS.NEAR_ABOVE if is_bull else Chan_EMA_POS.NEAR_BELOW + near_counter = Chan_EMA_POS.NEAR_BELOW if is_bull else Chan_EMA_POS.NEAR_ABOVE + cross_to_trend = Chan_EMA_POS.CROSS_CLOSE_ABOVE if is_bull else Chan_EMA_POS.CROSS_CLOSE_BELOW + cross_to_counter = Chan_EMA_POS.CROSS_CLOSE_BELOW if is_bull else Chan_EMA_POS.CROSS_CLOSE_ABOVE + + # COMBINE / INCLUDED 方向：只看位置，不区分强弱 + if not is_trend_kline and not is_counter_kline: + if ema_pos == trend_side: + return Chan_EMA_SEMANTIC.TREND_SIDE + elif ema_pos in (near_trend, cross_to_trend, Chan_EMA_POS.ON_EMA): + return Chan_EMA_SEMANTIC.APPROACHING + elif ema_pos in (near_counter, cross_to_counter): + return Chan_EMA_SEMANTIC.APPROACHING + elif ema_pos == counter_side: + return Chan_EMA_SEMANTIC.DEEP_COUNTER + return Chan_EMA_SEMANTIC.NEUTRAL + + # 逆势K线（多头下的下跌K线 / 空头下的上涨K线） + if is_counter_kline: + if ema_pos == trend_side: + return Chan_EMA_SEMANTIC.STRONG_TREND # 逆势K线仍在趋势侧（回调很浅） + elif ema_pos == near_trend: + return Chan_EMA_SEMANTIC.APPROACHING # 接近EMA，即将测试支撑/压力 + elif ema_pos == cross_to_trend: + return Chan_EMA_SEMANTIC.TOUCH_HOLD # 触碰EMA后守住趋势侧 + elif ema_pos == Chan_EMA_POS.ON_EMA: + return Chan_EMA_SEMANTIC.TOUCH_HOLD # 收盘在EMA附近，视为守住 + elif ema_pos == cross_to_counter: + return Chan_EMA_SEMANTIC.BREAK # 穿越EMA到逆势侧 + elif ema_pos == near_counter: + return Chan_EMA_SEMANTIC.BREAK # 接近EMA但收盘在逆势侧，也视为击穿 + elif ema_pos == counter_side: + return Chan_EMA_SEMANTIC.DEEP_COUNTER # 完全在逆势侧 + + # 顺势K线（多头下的上涨K线 / 空头下的下跌K线） + if is_trend_kline: + if ema_pos == counter_side: + return Chan_EMA_SEMANTIC.WEAK_COUNTER # 顺势K线却在逆势侧（弱势） + elif ema_pos == near_counter: + return Chan_EMA_SEMANTIC.APPROACHING # 从逆势侧接近EMA + elif ema_pos == cross_to_counter: + return Chan_EMA_SEMANTIC.TOUCH_FAIL # 触碰EMA但未穿越回趋势侧 + elif ema_pos == Chan_EMA_POS.ON_EMA: + return Chan_EMA_SEMANTIC.TOUCH_FAIL # 收盘在EMA附近，未确认突破 + elif ema_pos == cross_to_trend: + return Chan_EMA_SEMANTIC.RECOVER # 从逆势侧穿越回趋势侧 + elif ema_pos == near_trend: + return Chan_EMA_SEMANTIC.RECOVER # 接近趋势侧（刚收复EMA附近） + elif ema_pos == trend_side: + return Chan_EMA_SEMANTIC.TREND_SIDE # 完全在趋势侧（正常） + + return Chan_EMA_SEMANTIC.NEUTRAL + + @staticmethod + def semantic_to_int(semantic): + """将 Chan_EMA_SEMANTIC 枚举转换为整数，兼容旧的 ema52_status 数值""" + mapping = { + Chan_EMA_SEMANTIC.TOUCH_HOLD: 1, + Chan_EMA_SEMANTIC.BREAK: 2, + Chan_EMA_SEMANTIC.DEEP_COUNTER: 3, + Chan_EMA_SEMANTIC.TOUCH_FAIL: 4, + Chan_EMA_SEMANTIC.RECOVER: 5, + Chan_EMA_SEMANTIC.TREND_SIDE: 6, + Chan_EMA_SEMANTIC.STRONG_TREND: 7, + Chan_EMA_SEMANTIC.WEAK_COUNTER: 8, + Chan_EMA_SEMANTIC.APPROACHING: 9, + Chan_EMA_SEMANTIC.NEUTRAL: 0, + } + return mapping.get(semantic, 0) + + # threshold_pct: 阈值百分比，用于自动计算绝对阈值 + # 例如 0.001 表示 EMA 值的 0.1%，BTC $100,000 时 threshold = $100 + threshold_pct = 0.001 + + def cal_all_ema_status(self): + """ + 统一计算所有EMA与K线的位置关系和语义状态 + + threshold 自动按 EMA 值的百分比计算（cls.threshold_pct，默认0.1%） + - BTC $100,000 时：threshold ≈ $100 + - ETH $3,000 时：threshold ≈ $3 + - SOL $200 时：threshold ≈ $0.2 + + 结果存储在 self.ema_status 字典中，格式： + { + 'ema24': {'pos': Chan_EMA_POS, 'semantic': Chan_EMA_SEMANTIC, 'value': float, 'threshold': float}, + 'ema52': {...}, + ... + } + + 同时保持向后兼容：self.ema52_pos 和 self.ema52_status + """ + ema_configs = { + 'ema24': self.ema24, + 'ema52': self.ema52, + 'ema104': self.ema104, + 'ema156': self.ema156, + 'ema208': self.ema208, + } + self.ema_status = {} + for name, value in ema_configs.items(): + # 按 EMA 值的百分比自动计算阈值 + threshold = abs(value) * self.threshold_pct if value and self.threshold_pct > 0 else 0 + pos = ChanKLC.cal_ema_pos(self.high, self.low, self.close, value, threshold) + semantic = ChanKLC.cal_ema_semantic(pos, self.dir, self.ema_dir) + self.ema_status[name] = { + 'pos': pos, + 'semantic': semantic, + 'value': value, + 'threshold': threshold, + } + # 向后兼容 + self.ema52_pos = self.ema_status['ema52']['pos'] + self.ema52_status = ChanKLC.semantic_to_int(self.ema_status['ema52']['semantic']) + + def get_ema_pos(self, ema_name): + """获取指定EMA的客观位置，如 klc.get_ema_pos('ema24')""" + if ema_name in self.ema_status: + return self.ema_status[ema_name]['pos'] + return Chan_EMA_POS.UNKNOWN + + def get_ema_semantic(self, ema_name): + """获取指定EMA的语义状态，如 klc.get_ema_semantic('ema52')""" + if ema_name in self.ema_status: + return self.ema_status[ema_name]['semantic'] + return Chan_EMA_SEMANTIC.NEUTRAL def set_trend(self, trend): self.trend = trend def to_string(self): @@ -123,14 +359,23 @@ class ChanKLC(): self.rsi += self.klu_list[index].rsi self.volume_ratio += self.klu_list[index].volume_ratio self.macdhist += self.klu_list[index].macdhist - self.ema52 += self.klu_list[index].ema52 self.ema24 += self.klu_list[index].ema24 - self.rsi = self.rsi / len(self.klu_list) - self.volume_ratio = self.volume_ratio / len(self.klu_list) - self.volume = self.volume / len(self.klu_list) - self.macdhist = self.macdhist / len(self.klu_list) - self.ema52 = self.ema52 / len(self.klu_list) - self.ema24 = self.ema24 / len(self.klu_list) + self.ema52 += self.klu_list[index].ema52 + self.ema104 += self.klu_list[index].ema104 + self.ema156 += self.klu_list[index].ema156 + self.ema208 += self.klu_list[index].ema208 + if self.ema_dir != self.klu_list[index].ema_dir: + self.ema_dir = 0 + n = len(self.klu_list) + self.rsi = self.rsi / n + self.volume_ratio = self.volume_ratio / n + self.volume = self.volume / n + self.macdhist = self.macdhist / n + self.ema24 = self.ema24 / n + self.ema52 = self.ema52 / n + self.ema104 = self.ema104 / n + self.ema156 = self.ema156 / n + self.ema208 = self.ema208 / n if len(self.klu_list) > 0: self.macd = self.klu_list[-1].macd self.signal = self.klu_list[-1].signal diff --git a/ChanKLU.py b/ChanKLU.py index 0934a66..117a3dd 100644 --- a/ChanKLU.py +++ b/ChanKLU.py @@ -69,6 +69,8 @@ class ChanKLU: self.mode4_touch52_no_zero = False # 先触碰EMA52但黄白线未归零 self.div_type = "none" # {bearish, bullish, hidden_bearish, hidden_bullish, none} self.div_score = 0.0 # 背离强度(0-100) + self.ema_dir = 0 + self.get_ema_dir() #print(self.open, self.close, self.high, self.low, self.candle_dir, self.strength) def set_macd_state(self, state): self.macd_state = state @@ -123,14 +125,14 @@ class ChanKLU: return 0 else: return 0 - def ema_pattern(self): + def get_ema_dir(self): if self.check_indicators(): if self.ema24 > self.ema52 and self.ema52 > self.ema104 and self.ema104 > self.ema156: - return 1 + self.ema_dir = 1 elif self.ema24 < self.ema52 and self.ema52 < self.ema104 and self.ema104 < self.ema156: - return -1 + self.ema_dir = -1 else: - return 0 + self.ema_dir = 0 def check_indicators(self): if self.ema156 == 0: return False diff --git a/ChanLun.py b/ChanLun.py index 936053b..a6f6c0b 100644 --- a/ChanLun.py +++ b/ChanLun.py @@ -51,9 +51,9 @@ class ChanLun(): self.time1y = 12*30*24*60 self.time_M_intervals = [2*30*24*60, 3*30*24*60, 6*30*24*60, 12*30*24*60] self.time_M_symbols = ['2M', '3M', '6M', '1y'] - self.time_symbols = ['1m', '2m', '3m', '5m', '10m', '15m', '20m', '30m', '45m','1h', '2h', '4h', '6h', '8h', '12h', '16h', '1d', '2d', '3d', '1w', '2w', '1M', '3M', '6M', '1y'] + self.time_symbols = ['1m', '2m', '3m', '5m', '10m', '15m', '20m', '30m', '45m','1h', '2h', '4h', '6h', '8h', '12h', '16h', '1d', '2d', '3d'] self.tf_df_dict = {} - self.ema_symbols = ['5m', '10m', '15m', '20m', '30m', '45m', '1h', '2h', '4h', '6h', '8h', '12h', '16h', '1d', '2d', '3d'] + self.ema_symbols = ['5m', '15m', '30m', '45m', '1h', '2h', '4h', '8h', '12h', '1d', '2d', '3d'] self.tf_df = TF_DF() def init_data(self, dataframe, intervals, timeframes): for index in range(0, len(intervals)): @@ -74,10 +74,10 @@ class ChanLun(): if dataframe_d is not None: self.tf_df_dict['1d'] = TF_DF(dataframe_d, 1, '1d') self.init_data(dataframe_d, self.time_d_intervals, self.time_d_symbols) - if dataframe_w is not None: + if dataframe_w is not None and False: self.tf_df_dict['1w'] = TF_DF(dataframe_w, 1, '1w') self.init_data(dataframe_w, self.time_w_intervals, self.time_w_symbols) - if dataframe_M is not None: + if dataframe_M is not None and False: self.tf_df_dict['1M'] = TF_DF(dataframe_M, 1, '1M') self.init_data(dataframe_M, self.time_M_intervals, self.time_M_symbols) def get_ema52_dict(self): @@ -105,7 +105,12 @@ class ChanLun(): if abs(price - ema52_dict[key]) < 100: key_list.append(key) return key_list - + def get_ema_bsp(self, long_tf='1h', short_tf='15m'): + if long_tf in self.tf_df_dict and short_tf in self.tf_df_dict: + long_df = self.tf_df_dict[long_tf] + short_df = self.tf_df_dict[short_tf] + return long_df.get_ema_bsp(short_df) + return None diff --git a/K线动能理论.txt b/K线动能理论.txt index 26f4382..09e598a 100644 --- a/K线动能理论.txt +++ b/K线动能理论.txt @@ -12,8 +12,15 @@ 大周期看多，小周期跌完做多，跌完：顶分型和EMA52归零轴反弹 大周期看空，小周期涨完做空，涨完：顶分型和EMA52归零轴反抽 -多周期EMA52 - +中枢分类 +常规中枢 +上升中枢 +收敛中枢 +扩散中枢 +下行中枢 +止损放到顶底分型的高低点 +1. 从大周期开始找到价格接近ema52，MACD也接近零轴的周期，需要看这个周期的长级别是否高位空，大趋势方向 +2. 然后去小于这个时间周期的周期找买卖点，小级趋势方向和大趋势相反并且开始反向，小级别需要检查MACD是否归零轴反转，同时价格是否接近EMA52 EMA52线的反弹比零轴的反弹弱 diff --git a/TF_DF.py b/TF_DF.py index a66e24c..2100b79 100644 --- a/TF_DF.py +++ b/TF_DF.py @@ -40,6 +40,7 @@ class TF_DF(): self.zs_list = [] self.bsp_list = [] self.seg_list = [] + self.klc_fx_list = [] self.klu_list = self.cal_kl_data(self.dataframe) self.klc_list = self.get_klc_list(self.klu_list) self.bi_list = self.cal_bi_list(self.klc_list) @@ -47,6 +48,8 @@ class TF_DF(): self.zs_list = self.get_zs_list(self.bi_list, self.seg_list) self.chanmacd = ChanMACD(self.klu_list) self.klu_list = self.chanmacd.cal_macd_state() + + def get_ema52(self, index=-1): if self.klu_list: ema52_value = self.klu_list[index].ema52 @@ -136,14 +139,14 @@ class TF_DF(): return klu_state_list def check_fx(self, klc): if klc.pre and klc.next: - if klc.high > klc.pre.high and klc.high > klc.next.high and klc.low > klc.pre.low and klc.low > klc.next.low: + if klc.high > klc.pre.high and klc.high > klc.next.high and klc.low > klc.pre.low and klc.low > klc.next.low and klc.macd > 0: if klc.pre.pre and klc.next.next: if klc.high > klc.pre.pre.high and klc.high > klc.next.next.high: #if (klc.close > klc.ema52 or klc.next.close > klc.next.ema52) and klc.macd > 0: klc.set_fx(Chan_FX_TYPE.TOP) #print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "TOP") return Chan_FX_TYPE.TOP - elif klc.low < klc.pre.low and klc.low < klc.next.low and klc.high < klc.pre.high and klc.high < klc.next.high: + elif klc.low < klc.pre.low and klc.low < klc.next.low and klc.high < klc.pre.high and klc.high < klc.next.high and klc.macd < 0: if klc.pre.pre and klc.next.next: if klc.low < klc.pre.pre.low and klc.low < klc.next.next.low: #if (klc.close < klc.ema52 or klc.next.close < klc.next.ema52) and klc.macd < 0: diff --git a/config/ChanLun_EMA_Align.json b/config/ChanLun_EMA_Align.json new file mode 100644 index 0000000..db786c1 --- /dev/null +++ b/config/ChanLun_EMA_Align.json @@ -0,0 +1,83 @@ +{ + "$schema": "https://schema.freqtrade.io/schema.json", + "max_open_trades": 1, + "stake_currency": "USDT", + "stake_amount": "unlimited", + "tradable_balance_ratio": 0.99, + "fiat_display_currency": "USD", + "dry_run": true, + "db_url": "sqlite:///tradesv3.chanlun_btc_15.sqlite", + "dry_run_wallet": 1000, + "cancel_open_orders_on_exit": true, + "trading_mode": "futures", + "margin_mode": "isolated", + "can_short" : true, + "timeframe" : "1m", + "process_only_new_candles" : false, + "unfilledtimeout": { + "entry": 1, + "exit": 1, + "exit_timeout_count": 5, + "unit": "minutes" + }, + "entry_pricing": { + "price_side": "same", + "use_order_book": true, + "order_book_top": 1, + "price_last_balance": 0.0, + "check_depth_of_market": { + "enabled": false, + "bids_to_ask_delta": 1 + } + }, + "exit_pricing":{ + "price_side": "same", + "use_order_book": true, + "order_book_top": 1 + }, + "exchange": { + "name": "binance", + "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8", + "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l", + "ccxt_config": {}, + "ccxt_async_config": {}, + "pair_whitelist": [ + "BTC/USDT:USDT" + ], + "pair_blacklist": [ + "BNB/.*" + ] + }, + "pairlists": [ + { + "method": "StaticPairList", + "number_assets": 1, + "sort_key": "quoteVolume", + "min_value": 0, + "refresh_period": 1800 + } + ], + "telegram": { + "enabled": true, + "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y", + "chat_id": "580807463" + }, + "api_server": { + "enabled": true, + "listen_ip_address": "0.0.0.0", + "listen_port": 8820, + "verbosity": "error", + "enable_openapi": false, + "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d", + "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg", + "CORS_origins": [], + "username": "freqtrader", + "password": "FreqTrade007" + }, + "bot_name": "freqtrade", + "initial_state": "running", + "force_entry_enable": false, + "internals": { + "process_throttle_secs": 2 + } +} \ No newline at end of file diff --git a/strategies/ChanLun_EMA52.py b/strategies/ChanLun_EMA52.py index 77900a2..6af06e7 100644 --- a/strategies/ChanLun_EMA52.py +++ b/strategies/ChanLun_EMA52.py @@ -18,12 +18,23 @@ from typing import Optional import logging logger = logging.getLogger(__name__) """ -使用EMA周期52 -1. 检查当前price是否穿越，如果穿越时，MACD也是归零轴反转，则开仓 -2. 接近某个EMA周期后反转，此时MACD归零轴反转，则开仓 -止损放到顶底分型的高低点 -1. 从大周期开始找到价格接近ema52，MACD也接近零轴的周期，需要看这个周期的长级别是否高位空，大趋势方向 -2. 然后去小于这个时间周期的周期找买卖点，小级趋势方向和大趋势相反并且开始反向，小级别需要检查MACD是否归零轴反转，同时价格是否接近EMA52 +大周期：1h +小周期：15m，30m +大周期EMA156以下找做空机会 +找到最近的中枢，中枢下跌以后穿过EMA156，EMA52均线，形成死叉，macd黄白线穿越0轴 +EMA24，EMA52，EMA104，EMA156成下跌趋势依次排列（EMA156 > EMA104 > EMA52 > EMA24） +做空 +1. 做空开始点位条件： +确定下跌周期，价格在大于大周期的时间周期找到MACD归零轴+EMA52阻力线，按照K线动能理论，小周期确认是否背驰，背驰则开仓并且MACD穿零轴 +止损放到最近的顶分型高点或者价格突破EMA156 +2. 开始点位止盈策略 +计算盈亏比方式：至少1:2，到达1:2后平仓一半，移动止损到开仓价，1:3再平仓剩下的一半仓位，依次类推 +如果大周期遇到底背离可以平完所有仓位 +3. 加仓点位 +小周期顶分型+价格接近或突破大周期EMA24但是不突破EMA52后下跌可以加仓到最大仓位+大周期黄白线归零轴/小周期顶分型+小周期EMA52归零轴 +大周期顶分型+大周期macd归零轴可以加仓到最大仓位 +大周期顶分型或顶分型后，macd穿零轴后价格和macd红绿柱背驰可以加仓到最大仓位 +小周期顶分型+大周期macd归零轴 """ ### Now you can use logger.info('asfd') to log @@ -31,7 +42,7 @@ logger = logging.getLogger(__name__) # freqtrade trade -c ./user_data/Chan/config/ChanLun_EMA52.json --strategy ChanLun_EMA52 --strategy-path ./user_data/Chan/strategies # freqtrade backtesting -c ./user_data/Chan/config/ChanLun_EMA52.json --strategy ChanLun_EMA52 --strategy-path ./user_data/Chan/strategies --timerange=20260101- -# freqtrade download-data -c ./user_data/Chan/config/ChanLun_EMA52.json -t 1m 1m 1h 1d 1M --pairs BTC/USDT:USDT --timerange=20250405- +# freqtrade download-data -c ./user_data/Chan/config/ChanLun_EMA52.json -t 1m 1m 1h 1d 1w 1M --pairs BTC/USDT:USDT --timerange=20240101- # freqtrade download-data -c ./user_data/Chan/config/ChanLun_EMA52.json -t 1m 1h 1d 1M --pairs BTC/USDT --timerange=20170101- # freqtrade hyperopt --hyperopt-loss SharpeHyperOptLossDaily --spaces roi --strategy ChanLun_EMA52 --strategy-path ./user_data/Chan/strategies -c ./user_data/Chan/config/ChanLun_EMA52.json -e 200 --timerange=20250201-20250901 # freqtrade edge -c ./user_data/Chan/config/ChanLun_EMA52.json --strategy ChanLun_EMA52 --strategy-path ./user_data/Chan/strategies --timerange 20250721-20250901 @@ -101,34 +112,99 @@ class ChanLun_EMA52(IStrategy): def informative_pairs(self): return [(self.pair, "1h"), (self.pair, "1d"), - (self.pair, "1M"), + #(self.pair, "1M"), (self.pair, "15m"), - (self.pair, "1w"), + #(self.pair, "1w"), ] def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: dataframe = self.add_indicators(dataframe) long_df = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1h') long_df = self.add_indicators(long_df) - long_df['entry_long'] = self.long_entry_condition(long_df) dataframe['rsi'] = ta.RSI(long_df, timeperiod=14) - if self.last_time is None or self.last_time + timedelta(minutes=1) < datetime.now(): + if self.last_time is None or self.last_time + timedelta(seconds=10) < datetime.now(): self.last_time = datetime.now() logger.info("init_dataframes----------------------------") last_price = dataframe.iloc[-1]['close'] - macdstr = str(long_df.iloc[-1]['macd']) + " " + str(long_df.iloc[-1]['macdsignal']) + " " + str(long_df.iloc[-1]['macdhist']) date = dataframe.iloc[-1]['date'] tf_ema52_list = self.chan.check_price_ema52(last_price) self.init_dataframes(dataframe) - logger.info("Date: " + date.strftime('%Y-%m-%d %H:%M:%S') + " Price: " + str(last_price) + " EMA52_list: " + str(tf_ema52_list) + " MACD: " + macdstr) + logger.info("Date: " + date.strftime('%Y-%m-%d %H:%M:%S') + " Price: " + str(last_price) + " EMA52_list: " + str(tf_ema52_list)) + #print(long_df.iloc[-1]) dataframe = resampled_merge(dataframe, long_df) - #print(dataframe.iloc[-1]) return dataframe - def long_entry_condition(self, long_df): - long_entry_condition = (long_df['dir52'] > 0) & (long_df['dir156'] > 0) & (long_df['macdhist'] > 0) - return long_entry_condition + def ema_dir(self, dataframe): + """ + 趋势方向综合判断，分为三个维度： + + 1. ema_dir: 主趋势方向 (基于MACD零轴 + 价格与EMA52/EMA156关系) + - 3: 强多（价格在EMA156上方 + MACD在零轴上方 + 价格在EMA24上方） + - 2: 中多（价格在EMA156上方 + MACD在零轴上方） + - 1: 弱多（价格在EMA52上方 或 MACD在零轴上方，满足其一） + - -1: 弱空（价格在EMA52下方 或 MACD在零轴下方，满足其一） + - -2: 中空（价格在EMA156下方 + MACD在零轴下方） + - -3: 强空（价格在EMA156下方 + MACD在零轴下方 + 价格在EMA24下方） + - 0: 盘整（无明确方向） + + 2. ema_align: EMA排列状态（辅助确认趋势强度） + - 1: 多头排列 (EMA24 > EMA52 > EMA104 > EMA156) + - -1: 空头排列 (EMA24 < EMA52 < EMA104 < EMA156) + - 0: 交叉/纠缠 + + 3. ema_slope: EMA52斜率方向（趋势加速/减速判断） + - 正值: EMA52向上倾斜，趋势加速 + - 负值: EMA52向下倾斜，趋势减速 + """ + close = dataframe['close'] + ema24 = dataframe['ema24'] + ema52 = dataframe['ema52'] + ema104 = dataframe['ema104'] + ema156 = dataframe['ema156'] + macd_signal = dataframe['macdsignal'] # 黄线（慢线），用于判断零轴 + + # === 1. 主趋势方向 === + # 核心条件：价格与EMA156的关系（大趋势）+ MACD黄线与零轴的关系 + above_ema156 = close > ema156 + below_ema156 = close < ema156 + above_ema52 = close > ema52 + below_ema52 = close < ema52 + above_ema24 = close > ema24 + below_ema24 = close < ema24 + macd_above_zero = macd_signal > 0 + macd_below_zero = macd_signal < 0 + + dataframe['ema_dir'] = 0 + # 强多：价格在EMA156上方 + MACD零轴上方 + 价格在EMA24上方（超强势结构） + dataframe.loc[above_ema156 & macd_above_zero & above_ema24, 'ema_dir'] = 3 + # 中多：价格在EMA156上方 + MACD零轴上方 + dataframe.loc[above_ema156 & macd_above_zero & ~above_ema24, 'ema_dir'] = 2 + # 弱多：满足其一（价格在EMA52上方 或 MACD零轴上方） + dataframe.loc[(above_ema52 & ~macd_above_zero) | (macd_above_zero & ~above_ema156), 'ema_dir'] = 1 + # 弱空：满足其一（价格在EMA52下方 或 MACD零轴下方） + dataframe.loc[(below_ema52 & ~macd_below_zero) | (macd_below_zero & ~below_ema156), 'ema_dir'] = -1 + # 中空：价格在EMA156下方 + MACD零轴下方 + dataframe.loc[below_ema156 & macd_below_zero & ~below_ema24, 'ema_dir'] = -2 + # 强空：价格在EMA156下方 + MACD零轴下方 + 价格在EMA24下方（超强空势结构） + dataframe.loc[below_ema156 & macd_below_zero & below_ema24, 'ema_dir'] = -3 + + # === 2. EMA排列状态（辅助参考）=== + bull_align = (ema24 > ema52) & (ema52 > ema104) & (ema104 > ema156) + bear_align = (ema24 < ema52) & (ema52 < ema104) & (ema104 < ema156) + dataframe['ema_align'] = 0 + dataframe.loc[bull_align, 'ema_align'] = 1 + dataframe.loc[bear_align, 'ema_align'] = -1 + + # === 3. EMA52斜率（趋势加速/减速）=== + # 用EMA52的变化率判断趋势是否在加速 + dataframe['ema_slope'] = (ema52 - ema52.shift(3)) / ema52.shift(3) * 100 + + return dataframe def add_indicators(self, dataframe): + dataframe['ema24'] = ta.EMA(dataframe, timeperiod=24) + dataframe['dir24'] = dataframe['close'] - dataframe['ema24'] dataframe['ema52'] = ta.EMA(dataframe, timeperiod=52) dataframe['dir52'] = dataframe['close'] - dataframe['ema52'] + dataframe['ema104'] = ta.EMA(dataframe, timeperiod=104) + dataframe['dir104'] = dataframe['close'] - dataframe['ema104'] dataframe['ema156'] = ta.EMA(dataframe, timeperiod=156) dataframe['dir156'] = dataframe['close'] - dataframe['ema156'] dataframe['dir52_156'] = dataframe['dir52'] - dataframe['dir156'] @@ -141,10 +217,9 @@ class ChanLun_EMA52(IStrategy): dataframe_15m = self.dp.get_pair_dataframe(pair=self.pair, timeframe='15m') dataframe_1h = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1h') dataframe_1d = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1d') - dataframe_1w = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1w') - dataframe_1M = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1M') - self.chan = ChanLun() - self.chan.init_dataframes(dataframe_1m, dataframe_15m,dataframe_1h, dataframe_1d, dataframe_1w, dataframe_1M) + #dataframe_1w = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1w') + #dataframe_1M = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1M') + self.chan.init_dataframes(dataframe_1m, dataframe_15m,dataframe_1h, dataframe_1d) def custom_entry_price(self, pair: str, trade: Trade | None, current_time: datetime, proposed_rate: float, entry_tag: str | None, side: str, **kwargs) -> float: new_entryprice = proposed_rate @@ -182,7 +257,6 @@ class ChanLun_EMA52(IStrategy): def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: dataframe.loc[ - (dataframe['rsi'] < 30) & (dataframe['dir156'] > 0) & (dataframe['dir52_156'] > 0) & (dataframe['macdhist'] > 0), @@ -190,7 +264,6 @@ class ChanLun_EMA52(IStrategy): return dataframe def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: dataframe.loc[ - (dataframe['rsi'] > 70) & (dataframe['dir156'] < 0) & (dataframe['dir52_156'] < 0) & (dataframe['macdhist'] < 0), diff --git a/strategies/ChanLun_EMA_Align.py b/strategies/ChanLun_EMA_Align.py new file mode 100644 index 0000000..f345571 --- /dev/null +++ b/strategies/ChanLun_EMA_Align.py @@ -0,0 +1,201 @@ +# --- Do not remove these libs --- +from statistics import median +from freqtrade.strategy import IStrategy, stoploss_from_absolute +import sys +import os +# 添加父目录到系统路径 +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +from ChanLun import ChanLun +from ChanEnum import Chan_FX_TYPE, Chan_KLC_FX, Chan_BI_DIR, Chan_KLC_FX +# -------------------------------- +from technical.util import resample_to_interval, resampled_merge +import talib.abstract as ta +from pandas import DataFrame +import pandas as pd +from datetime import datetime, timedelta +from freqtrade.persistence import Trade, Order +from typing import Optional +import logging +logger = logging.getLogger(__name__) +""" +大周期：1h +小周期：15m，30m +大周期EMA156以下找做空机会 +找到最近的中枢，中枢下跌以后穿过EMA156，EMA52均线，形成死叉，macd黄白线穿越0轴 +EMA24，EMA52，EMA104，EMA156成下跌趋势依次排列（EMA156 > EMA104 > EMA52 > EMA24） +做空 +1. 做空开始点位条件： +确定下跌周期，价格在大于大周期的时间周期找到MACD归零轴+EMA52阻力线，按照K线动能理论，小周期确认是否背驰，背驰则开仓并且MACD穿零轴 +止损放到最近的顶分型高点或者价格突破EMA156 +2. 开始点位止盈策略 +计算盈亏比方式：至少1:2，到达1:2后平仓一半，移动止损到开仓价，1:3再平仓剩下的一半仓位，依次类推 +如果大周期遇到底背离可以平完所有仓位 +3. 加仓点位 +小周期顶分型+价格接近或突破大周期EMA24但是不突破EMA52后下跌可以加仓到最大仓位+大周期黄白线归零轴/小周期顶分型+小周期EMA52归零轴 +大周期顶分型+大周期macd归零轴可以加仓到最大仓位 +大周期顶分型或顶分型后，macd穿零轴后价格和macd红绿柱背驰可以加仓到最大仓位 +小周期顶分型+大周期macd归零轴 +""" + +### Now you can use logger.info('asfd') to log +# freqtrade plot-dataframe --strategy ChanLun_BTC --datadir user_data/data/binance -c ./user_data/ChanLun_SOL_30.json --timerange=20250309- + +# freqtrade trade -c ./user_data/Chan/config/ChanLun_EMA_Align.json --strategy ChanLun_EMA_Align --strategy-path ./user_data/Chan/strategies +# freqtrade backtesting -c ./user_data/Chan/config/ChanLun_EMA_Align.json --strategy ChanLun_EMA_Align --strategy-path ./user_data/Chan/strategies --timerange=20260101- +# freqtrade download-data -c ./user_data/Chan/config/ChanLun_EMA_Align.json -t 1m 1m 1h 1d 1w 1M --pairs BTC/USDT:USDT --timerange=20240101- +# freqtrade download-data -c ./user_data/Chan/config/ChanLun_EMA_Align.json -t 1m 1h 1d 1M --pairs BTC/USDT --timerange=20170101- +# freqtrade hyperopt --hyperopt-loss SharpeHyperOptLossDaily --spaces roi --strategy ChanLun_EMA_Align --strategy-path ./user_data/Chan/strategies -c ./user_data/Chan/config/ChanLun_EMA_Align.json -e 200 --timerange=20250201-20250901 +# freqtrade edge -c ./user_data/Chan/config/ChanLun_EMA_Align.json --strategy ChanLun_EMA_Align --strategy-path ./user_data/Chan/strategies --timerange 20250721-20250901 +# freqtrade plot-dataframe -c ./user_data/Chan/config/ChanLun_EMA_Align.json --strategy ChanLun_EMA_Align --strategy-path ./user_data/Chan/strategies --timerange 20250721-20250901 + +# sudo docker compose run --rm chanlun_btc backtesting -c ./user_data/Chan/config/ChanLun_EMA_Align.json --strategy ChanLun_EMA_Align --strategy-path ./user_data/Chan/strategies --timerange=20250721- +# sudo docker compose run --rm chanlun_btc download-data -c ./user_data/Chan/config/ChanLun_EMA_Align.json --pairs BTC/USDT:USDT -t 1m --timerange 20240101- +# sudo docker compose run --rm chanlun_btc trade -c ./user_data/Chan/config/ChanLun_EMA_Align.json --strategy ChanLun_EMA_Align --strategy-path ./user_data/Chan/strategies + +class ChanLun_EMA_Align(IStrategy): + INTERFACE_VERSION: int = 3 + # Minimal ROI designed for the strategy. + # This attribute will be overridden if the config file contains "minimal_roi" + # 30m and 1h + + minimal_roi = { + "0": 0.15, + "360": 0.2, + "640": 0.1, + "1200": 0 + } + # 5m and 15m + minimal_roi_1 = { + "0": 0.1, + "60": 0.05, + "120": 0.02, + "240": 0 + } + # 15m and 30m + minimal_roi_1 = { + "0": 0.1, + "240": 0.05, + "480": 0.03, + "600": 0 + } + minimal_roi_1 = { + "0": 1.50, + "120": 0.05, + "240": 0.025, + "360": 0 + } + startup_candle_count = 1600 + can_short = True + lev = 1.0 + stoploss = -0.3 # 设置为很大的负值，让custom_stoploss来控制 + use_custom_stoploss = False # 启用自定义止损 + + trailing_stop = False + trailing_stop_positive = 0.03 + trailing_stop_positive_offset = 0.06 + trailing_only_offset_is_reached = False + + # 关闭分批止盈/仓位调整 + position_adjustment_enable = False + # startup_candle_count = 1600 + time5 = 5 + time15 = 15 + time30 = 30 + time60 = 60 + def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + dataframe = self.add_indicators(dataframe) + dataframe_5m = resample_to_interval(dataframe, self.get_ticker_indicator() * self.time5) + dataframe_5m = self.add_indicators(dataframe_5m) + #print(dataframe_5m.iloc[-1]) + dataframe = resampled_merge(dataframe, dataframe_5m) + return dataframe + def add_indicators(self, dataframe): + dataframe['ema24'] = ta.EMA(dataframe, timeperiod=24) + dataframe['dir24'] = dataframe['close'] - dataframe['ema24'] + dataframe['ema52'] = ta.EMA(dataframe, timeperiod=52) + dataframe['dir52'] = dataframe['close'] - dataframe['ema52'] + dataframe['ema104'] = ta.EMA(dataframe, timeperiod=104) + dataframe['dir104'] = dataframe['close'] - dataframe['ema104'] + dataframe['ema156'] = ta.EMA(dataframe, timeperiod=156) + dataframe['dir156'] = dataframe['close'] - dataframe['ema156'] + dataframe['dir52_156'] = dataframe['ema52'] - dataframe['ema156'] + dataframe['dir52_104'] = dataframe['ema52'] - dataframe['ema104'] + dataframe_macd = ta.MACD(dataframe, fast=12, slow=26, signal=9) + dataframe['macdsignal'] = dataframe_macd['macdsignal'] + dataframe['macd'] = dataframe_macd['macd'] + dataframe['macdhist'] = dataframe_macd['macdhist'] + dataframe['ema_align'] = ( + ((dataframe['ema24'] > dataframe['ema52']) & (dataframe['ema52'] > dataframe['ema104'])) | + ((dataframe['ema24'] < dataframe['ema52']) & (dataframe['ema52'] < dataframe['ema104'])) + ) + return dataframe + def custom_entry_price(self, pair: str, trade: Trade | None, current_time: datetime, proposed_rate: float, + entry_tag: str | None, side: str, **kwargs) -> float: + new_entryprice = proposed_rate + if trade: + if trade.is_short: + new_entryprice = proposed_rate - 50 + else: + new_entryprice = proposed_rate + 50 + return new_entryprice + + def custom_exit_price(self, pair: str, trade: Trade, + current_time: datetime, proposed_rate: float, + current_profit: float, exit_tag: str | None, **kwargs) -> float: + new_exitprice = proposed_rate + if trade: + if trade.is_short: + new_exitprice = proposed_rate + 50 + else: + new_exitprice = proposed_rate - 50 + return new_exitprice + + def adjust_trade_position(self, trade: Trade, current_time: datetime, + current_rate: float, current_profit: float, + min_stake: Optional[float], max_stake: float, + current_entry_rate: float, current_exit_rate: float, + current_entry_profit: float, current_exit_profit: float, + **kwargs) -> Optional[float]: + # 关闭分批止盈，始终不调整仓位 + return None + + def custom_exit(self, pair: str, trade: Trade, current_time: datetime, current_rate: float, + current_profit: float, **kwargs): + # 不做分批止盈/最终止盈处理，退出由策略信号/ROI/止损决定 + return None + + def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + resample_5m_align = 'resample_{}_ema_align'.format(self.get_ticker_indicator() * self.time5) + # 使用高周期的 dir52_156 方向作为多空判定依据 + resample_5m_dir = 'resample_{}_dir52_104'.format(self.get_ticker_indicator() * self.time5) + resample_5m_signal = 'resample_{}_macdsignal'.format(self.get_ticker_indicator() * self.time5) + dataframe.loc[ + (dataframe[resample_5m_align]) & + (dataframe[resample_5m_dir] > 0) & + (dataframe[resample_5m_signal] > 0), + ['enter_long', 'enter_tag']] = (1, 'long_signal_chan') + dataframe.loc[ + (dataframe[resample_5m_align]) & + (dataframe[resample_5m_dir] < 0) & + (dataframe[resample_5m_signal] < 0), + ['enter_short', 'enter_tag']] = (1, 'short_signal_chan') + return dataframe + def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + dataframe.loc[ + (dataframe['dir156'] < 0) & + (dataframe['dir52_156'] < 0) & + (dataframe['macdhist'] < 0), + ['exit_long', 'exit_tag']] = (1, 'long_exit_signal_chan') + dataframe.loc[ + (dataframe['macd'] > 0) & + (dataframe['dir156'] > 0) & + (dataframe['dir52_156'] > 0) & + (dataframe['macdhist'] > 0), + ['exit_short', 'exit_tag']] = (1, 'short_exit_signal_chan') + return dataframe + def leverage(self, pair: str, current_time: datetime, current_rate: float, + proposed_leverage: float, max_leverage: float, entry_tag: Optional[str], side: str, + **kwargs) -> float: + return self.lev + def get_ticker_indicator(self): + return int(self.timeframe[:-1]) \ No newline at end of file